Remove NumberValueTypeConstructor

compiler/backend/src/org/jetbrains/jet/codegen/AnnotationCodegen.java

@@ -254,8 +254,8 @@ public abstract class AnnotationCodegen {
             }
 
             @Override
-            public Void visitNumberTypeValue(NumberValueTypeConstant value, Void data) {
+            public Void visitNumberTypeValue(IntegerValueTypeConstant value, Void data) {
-                NumberValueTypeConstructor typeConstructor = value.getValue();
+                IntegerValueTypeConstructor typeConstructor = value.getValue();
                 Object numberType = EvaluatePackage.getValueForNumberType(typeConstructor, expectedType);
                 if (numberType != null) {
                     annotationVisitor.visit(name, numberType);

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -51,8 +51,8 @@ import org.jetbrains.jet.lang.resolve.calls.model.*;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.calls.util.ExpressionAsFunctionDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
-import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstant;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstant;
-import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstructor;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstructor;
 import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
@@ -1243,9 +1243,9 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     @Nullable
     public static CompileTimeConstant getCompileTimeConstant(@NotNull JetExpression expression, @NotNull BindingContext bindingContext) {
         CompileTimeConstant<?> compileTimeValue = bindingContext.get(BindingContext.COMPILE_TIME_VALUE, expression);
-        if (compileTimeValue instanceof NumberValueTypeConstant) {
+        if (compileTimeValue instanceof IntegerValueTypeConstant) {
             JetType expectedType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression);
-            return EvaluatePackage.getCompileTimeConstantForNumberType((NumberValueTypeConstructor) compileTimeValue.getValue(), expectedType);
+            return EvaluatePackage.getCompileTimeConstantForNumberType((IntegerValueTypeConstructor) compileTimeValue.getValue(), expectedType);
         }
         return compileTimeValue;
     }

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.IntegerValueTypeConstant;
-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.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) {
+                if (constant instanceof IntegerValueTypeConstant) {
-                    NumberValueTypeConstructor typeConstructor = ((NumberValueTypeConstant) constant).getValue();
+                    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) {
+            if (type.getConstructor() instanceof IntegerValueTypeConstructor) {
-                NumberValueTypeConstructor constructor = (NumberValueTypeConstructor) type.getConstructor();
+                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/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) {
+        if (value instanceof IntegerValueTypeConstant && context.contextDependency == INDEPENDENT) {
-            expressionType = getPrimitiveNumberType(((NumberValueTypeConstant) value).getValue(), context.expectedType);
+            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) {
+            if (value instanceof IntegerValueTypeConstant) {
-                value = EvaluatePackage.getCompileTimeConstantForNumberType(((NumberValueTypeConstant) value).getValue(), expectedType);
+                value = EvaluatePackage.getCompileTimeConstantForNumberType(((IntegerValueTypeConstant) value).getValue(), expectedType);
             }
             new CompileTimeConstantChecker(trace, true).checkConstantExpressionType(value, (JetConstantExpression) expression, expectedType);
             return expressionType;

core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationArgumentVisitor.java

@@ -51,5 +51,5 @@ public interface AnnotationArgumentVisitor<R, D> {
 
     R visitJavaClassValue(JavaClassValue value, D data);
 
-    R visitNumberTypeValue(NumberValueTypeConstant value, D data);
+    R visitNumberTypeValue(IntegerValueTypeConstant value, D data);
 }

core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/IntegerValueTypeConstant.java

@@ -27,7 +27,13 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.util.Collections;
 
-public abstract class NumberValueTypeConstant<T extends Number> implements CompileTimeConstant<NumberValueTypeConstructor<T>> {
+public class IntegerValueTypeConstant implements CompileTimeConstant<IntegerValueTypeConstructor> {
+
+    private final IntegerValueTypeConstructor value;
+
+    public IntegerValueTypeConstant(long value) {
+        this.value = new IntegerValueTypeConstructor(value);
+    }
 
     @NotNull
     @Override
@@ -43,6 +49,14 @@ public abstract class NumberValueTypeConstant<T extends Number> implements Compi
         return visitor.visitNumberTypeValue(this, data);
     }
 
+    @NotNull
     @Override
-    public abstract NumberValueTypeConstructor<T> getValue();
+    public IntegerValueTypeConstructor getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return value.toString();
+    }
 }

core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/IntegerValueTypeConstructor.java

@@ -18,12 +18,19 @@ package org.jetbrains.jet.lang.resolve.constants;
 
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.types.TypeConstructor;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 
-public class IntegerValueTypeConstructor extends NumberValueTypeConstructor<Long> {
+public class IntegerValueTypeConstructor implements TypeConstructor {
     private final long value;
     private final Collection<JetType> supertypes = Lists.newArrayList();
 
@@ -44,17 +51,44 @@ public class IntegerValueTypeConstructor extends NumberValueTypeConstructor<Long
         }
     }
 
-    @Override
-    public Long getValue() {
-        return value;
-    }
-
     @NotNull
     @Override
     public Collection<JetType> getSupertypes() {
         return supertypes;
     }
 
+    @NotNull
+    @Override
+    public List<TypeParameterDescriptor> getParameters() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean isFinal() {
+        return false;
+    }
+
+    @Override
+    public boolean isDenotable() {
+        return false;
+    }
+
+    @Nullable
+    @Override
+    public ClassifierDescriptor getDeclarationDescriptor() {
+        return null;
+    }
+
+    @NotNull
+    @Override
+    public List<AnnotationDescriptor> getAnnotations() {
+        return Collections.emptyList();
+    }
+
+    public Long getValue() {
+        return value;
+    }
+
     @Override
     public String toString() {
         return "IntegerValueType(" + value + ")";

core/descriptors/src/org/jetbrains/jet/lang/resolve/constants/NumberValueTypeConstructor.java

@@ -1,59 +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;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
-import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.types.TypeConstructor;
-
-import java.util.Collections;
-import java.util.List;
-
-public abstract class NumberValueTypeConstructor<T extends Number> implements TypeConstructor {
-    @NotNull
-    @Override
-    public List<TypeParameterDescriptor> getParameters() {
-        return Collections.emptyList();
-    }
-
-    @Override
-    public boolean isFinal() {
-        return false;
-    }
-
-    @Override
-    public boolean isDenotable() {
-        return false;
-    }
-
-    @Nullable
-    @Override
-    public ClassifierDescriptor getDeclarationDescriptor() {
-        return null;
-    }
-
-    @NotNull
-    @Override
-    public List<AnnotationDescriptor> getAnnotations() {
-        return Collections.emptyList();
-    }
-
-    public abstract T getValue();
-}

core/descriptors/src/org/jetbrains/jet/lang/types/TypeUtils.java

@@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystemImpl;
-import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstructor;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstructor;
 import org.jetbrains.jet.lang.resolve.scopes.ChainedScope;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
@@ -594,7 +594,7 @@ public class TypeUtils {
     }
 
     @NotNull
-    public static JetType getDefaultPrimitiveNumberType(@NotNull NumberValueTypeConstructor numberValueTypeConstructor) {
+    public static JetType getDefaultPrimitiveNumberType(@NotNull IntegerValueTypeConstructor numberValueTypeConstructor) {
         JetType type = getDefaultPrimitiveNumberType(numberValueTypeConstructor.getSupertypes());
         assert type != null : "Strange number value type constructor: " + numberValueTypeConstructor + ". " +
                               "Super types doesn't contain double, int or long: " + numberValueTypeConstructor.getSupertypes();
@@ -620,7 +620,7 @@ public class TypeUtils {
 
     @NotNull
     public static JetType getPrimitiveNumberType(
-            @NotNull NumberValueTypeConstructor numberValueTypeConstructor,
+            @NotNull IntegerValueTypeConstructor numberValueTypeConstructor,
             @NotNull JetType expectedType
     ) {
         if (noExpectedType(expectedType) || expectedType.isError()) {
@@ -639,7 +639,7 @@ public class TypeUtils {
         Collection<JetType> numberTypes = Sets.newLinkedHashSet();
         Collection<JetType> otherTypes = Sets.newLinkedHashSet();
         for (JetType type : types) {
-            if (type.getConstructor() instanceof NumberValueTypeConstructor) {
+            if (type.getConstructor() instanceof IntegerValueTypeConstructor) {
                 numberTypes.add(type);
             }
             else {

js/js.translator/src/org/jetbrains/k2js/translate/expression/ExpressionVisitor.java

@@ -29,8 +29,8 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
+import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstructor;
 import org.jetbrains.jet.lang.resolve.constants.NullValue;
-import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstructor;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.k2js.translate.context.TemporaryVariable;
@@ -86,11 +86,11 @@ public final class ExpressionVisitor extends TranslatorVisitor<JsNode> {
         }
 
         Object value = compileTimeValue.getValue();
-        if (value instanceof NumberValueTypeConstructor) {
+        if (value instanceof IntegerValueTypeConstructor) {
             JetType expectedType = context.bindingContext().get(BindingContext.EXPRESSION_TYPE, expression);
             CompileTimeConstant<?> newConstant =
-                    EvaluatePackage.getCompileTimeConstantForNumberType((NumberValueTypeConstructor) value, expectedType);
+                    EvaluatePackage.getCompileTimeConstantForNumberType((IntegerValueTypeConstructor) value, expectedType);
-            assert newConstant != null: "NumberValueTypeConstant should always have notnull value " + compileTimeValue;
+            assert newConstant != null: "IntegerValueTypeConstant should always have notnull value " + compileTimeValue;
             value = newConstant.getValue();
         }
         if (value instanceof Integer || value instanceof Short || value instanceof Byte) {