Remove NumberValueTypeConstructor

compiler/frontend/src/org/jetbrains/jet/lang/evaluate/ConstantExpressionEvaluator.kt

@@ -389,7 +389,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
         val evaluationResult = evaluate(expression, expressionType)?.getValue()
         if (evaluationResult == null) return null
 
-        if (evaluationResult is NumberValueTypeConstructor<*>) {
+        if (evaluationResult is IntegerValueTypeConstructor) {
             val evaluationResultWithNewType = evaluationResult.getValueForNumberType(expressionType)
             if (evaluationResultWithNewType != null) {
                 return OperationArgument(evaluationResultWithNewType, compileTimeType, expression)
@@ -411,7 +411,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet
     }
 }
 
-public fun NumberValueTypeConstructor<out Number?>.getValueForNumberType(expectedType: JetType): Any? {
+public fun IntegerValueTypeConstructor.getValueForNumberType(expectedType: JetType): Any? {
     val valueWithNewType = this.getCompileTimeConstantForNumberType(expectedType)
     if (valueWithNewType != null) {
         return valueWithNewType.getValue()
@@ -419,7 +419,7 @@ public fun NumberValueTypeConstructor<out Number?>.getValueForNumberType(expecte
     return null
 }
 
-public fun NumberValueTypeConstructor<out Number?>.getCompileTimeConstantForNumberType(expectedType: JetType): CompileTimeConstant<*>? {
+public fun IntegerValueTypeConstructor.getCompileTimeConstantForNumberType(expectedType: JetType): CompileTimeConstant<*>? {
     val defaultType = TypeUtils.getPrimitiveNumberType(this, expectedType)
     return createConvertibleCompileTimeConstant(this.getValue(), defaultType)
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java

@@ -35,8 +35,8 @@ import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.constants.ArrayValue;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
-import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstant;
-import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstructor;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstant;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstructor;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.ErrorUtils;
@@ -247,8 +247,8 @@ public class AnnotationResolver {
             JetExpression argumentExpression = argument.getArgumentExpression();
             if (argumentExpression != null) {
                 CompileTimeConstant<?> constant = resolveExpressionToCompileTimeValue(argumentExpression, expectedType, trace);
-                if (constant instanceof NumberValueTypeConstant) {
-                    NumberValueTypeConstructor typeConstructor = ((NumberValueTypeConstant) constant).getValue();
+                if (constant instanceof IntegerValueTypeConstant) {
+                    IntegerValueTypeConstructor typeConstructor = ((IntegerValueTypeConstant) constant).getValue();
                     JetType defaultType = getPrimitiveNumberType(typeConstructor, expectedType);
                     ArgumentTypeResolver.updateNumberType(defaultType, argumentExpression, trace);
                 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java

@@ -29,7 +29,7 @@ import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.context.CheckValueArgumentsMode;
 import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.model.MutableDataFlowInfoForArguments;
-import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstructor;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstructor;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.JetTypeInfo;
@@ -266,8 +266,8 @@ public class ArgumentTypeResolver {
     ) {
         JetType type = context.trace.get(BindingContext.EXPRESSION_TYPE, expression);
         if (type != null && !type.getConstructor().isDenotable()) {
-            if (type.getConstructor() instanceof NumberValueTypeConstructor) {
-                NumberValueTypeConstructor constructor = (NumberValueTypeConstructor) type.getConstructor();
+            if (type.getConstructor() instanceof IntegerValueTypeConstructor) {
+                IntegerValueTypeConstructor constructor = (IntegerValueTypeConstructor) type.getConstructor();
                 JetType primitiveType = TypeUtils.getPrimitiveNumberType(constructor, context.expectedType);
                 updateNumberType(primitiveType, expression, context.trace);
                 return primitiveType;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/IntegerValueTypeConstant.java

@@ -1,39 +0,0 @@
-/*
- * Copyright 2010-2013 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.lang.resolve.constants;
-
-import org.jetbrains.annotations.NotNull;
-
-public class IntegerValueTypeConstant extends NumberValueTypeConstant<Long> {
-
-    private final IntegerValueTypeConstructor value;
-
-    public IntegerValueTypeConstant(long value) {
-        this.value = new IntegerValueTypeConstructor(value);
-    }
-
-    @NotNull
-    @Override
-    public IntegerValueTypeConstructor getValue() {
-        return value;
-    }
-
-    @Override
-    public String toString() {
-        return value.toString();
-    }
-}

compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/IntegerValueTypeConstructor.java

@@ -1,62 +0,0 @@
-/*
- * Copyright 2010-2013 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet.lang.resolve.constants;
-
-import com.google.common.collect.Lists;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
-
-import java.util.Collection;
-
-public class IntegerValueTypeConstructor extends NumberValueTypeConstructor<Long> {
-    private final long value;
-    private final Collection<JetType> supertypes = Lists.newArrayList();
-
-    public IntegerValueTypeConstructor(long value) {
-        // order of types matters
-        // 'getPrimitiveNumberType' returns first of supertypes that is a subtype of expected type
-        // for expected type 'Any' result type 'Int' should be returned
-        this.value = value;
-        checkBoundsAndAddSuperType(value, (long) Integer.MIN_VALUE, (long) Integer.MAX_VALUE, KotlinBuiltIns.getInstance().getIntType());
-        checkBoundsAndAddSuperType(value, (long) Byte.MIN_VALUE, (long) Byte.MAX_VALUE, KotlinBuiltIns.getInstance().getByteType());
-        checkBoundsAndAddSuperType(value, (long) Short.MIN_VALUE, (long) Short.MAX_VALUE, KotlinBuiltIns.getInstance().getShortType());
-        supertypes.add(KotlinBuiltIns.getInstance().getLongType());
-    }
-
-    private void checkBoundsAndAddSuperType(long value, long minValue, long maxValue, JetType kotlinType) {
-        if (value >= minValue && value <= maxValue) {
-            supertypes.add(kotlinType);
-        }
-    }
-
-    @Override
-    public Long getValue() {
-        return value;
-    }
-
-    @NotNull
-    @Override
-    public Collection<JetType> getSupertypes() {
-        return supertypes;
-    }
-
-    @Override
-    public String toString() {
-        return "IntegerValueType(" + value + ")";
-    }
-}

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java

@@ -49,7 +49,7 @@ import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantChecker;
-import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstant;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstant;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -122,7 +122,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     public JetTypeInfo visitConstantExpression(@NotNull JetConstantExpression expression, ExpressionTypingContext context) {
         CompileTimeConstant<?> value = ConstantExpressionEvaluator.object$.evaluate(expression, context.trace, context.expectedType);
 
-        if (!(value instanceof NumberValueTypeConstant)) {
+        if (!(value instanceof IntegerValueTypeConstant)) {
             CompileTimeConstantChecker compileTimeConstantChecker = context.getCompileTimeConstantChecker();
             boolean hasError = compileTimeConstantChecker.checkConstantExpressionType(value, expression, context.expectedType);
             if (hasError) {
@@ -710,8 +710,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             @NotNull ExpressionTypingContext context
     ) {
         JetType expressionType = value.getType(KotlinBuiltIns.getInstance());
-        if (value instanceof NumberValueTypeConstant && context.contextDependency == INDEPENDENT) {
-            expressionType = getPrimitiveNumberType(((NumberValueTypeConstant) value).getValue(), context.expectedType);
+        if (value instanceof IntegerValueTypeConstant && context.contextDependency == INDEPENDENT) {
+            expressionType = getPrimitiveNumberType(((IntegerValueTypeConstant) value).getValue(), context.expectedType);
             ArgumentTypeResolver.updateNumberType(expressionType, expression, context.trace);
         }
 

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java

@@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValueFactory;
 import org.jetbrains.jet.lang.resolve.calls.context.ResolutionContext;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantChecker;
-import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstant;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstant;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.JetTypeInfo;
 import org.jetbrains.jet.lang.types.TypeUtils;
@@ -170,8 +170,8 @@ public class DataFlowUtils {
 
         if (expression instanceof JetConstantExpression) {
             CompileTimeConstant<?> value = ConstantExpressionEvaluator.object$.evaluate(expression, trace, expectedType);
-            if (value instanceof NumberValueTypeConstant) {
-                value = EvaluatePackage.getCompileTimeConstantForNumberType(((NumberValueTypeConstant) value).getValue(), expectedType);
+            if (value instanceof IntegerValueTypeConstant) {
+                value = EvaluatePackage.getCompileTimeConstantForNumberType(((IntegerValueTypeConstant) value).getValue(), expectedType);
             }
             new CompileTimeConstantChecker(trace, true).checkConstantExpressionType(value, (JetConstantExpression) expression, expectedType);
             return expressionType;