From 80eb45b7937753ae704434d549d0523e8feab15d Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Mon, 22 Jul 2013 13:17:03 +0400 Subject: [PATCH] process number value types properly in constraint system the case when type parameter has number value types (constants) as lower bounds should be handled specially, because upper bound for primitive number types is 'Number', but by default we want Int (or Long) --- .../resolve/calls/ArgumentTypeResolver.java | 19 +- .../lang/resolve/calls/CandidateResolver.java | 10 +- .../calls/inference/ConstraintsUtil.java | 170 +++++++++++++----- .../calls/inference/TypeConstraintsImpl.java | 17 ++ .../constants/NumberValueTypeConstructor.java | 41 +++-- .../numbers/numbersInSimpleConstraints.kt | 66 +++++++ .../checkers/JetDiagnosticsTestGenerated.java | 16 +- 7 files changed, 268 insertions(+), 71 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java index 8ea35542bec..a2d60b9c165 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java @@ -29,14 +29,12 @@ 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.context.ResolveMode; +import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintsUtil; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument; import org.jetbrains.jet.lang.resolve.constants.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.types.ErrorUtils; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.JetTypeInfo; -import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -71,16 +69,13 @@ public class ArgumentTypeResolver { } public static boolean isSubtypeOfForArgumentType( - @NotNull JetType subtype, - @NotNull JetType supertype + @NotNull JetType actualType, + @NotNull JetType expectedType ) { - if (subtype == PLACEHOLDER_FUNCTION_TYPE) { - return isFunctionOrErrorType(supertype) || KotlinBuiltIns.getInstance().isAny(supertype); //todo function type extends + if (actualType == PLACEHOLDER_FUNCTION_TYPE) { + return isFunctionOrErrorType(expectedType) || KotlinBuiltIns.getInstance().isAny(expectedType); //todo function type extends } - if (supertype == PLACEHOLDER_FUNCTION_TYPE) { - return isFunctionOrErrorType(subtype); //todo extends function type - } - return JetTypeChecker.INSTANCE.isSubtypeOf(subtype, supertype); + return JetTypeChecker.INSTANCE.isSubtypeOf(actualType, expectedType); } private static boolean isFunctionOrErrorType(@NotNull JetType supertype) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java index 72ab3c4fe8f..a4a70ac1c1c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CandidateResolver.java @@ -39,6 +39,8 @@ import org.jetbrains.jet.lang.resolve.calls.results.ResolutionStatus; import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionTask; import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer; import org.jetbrains.jet.lang.resolve.calls.util.ExpressionAsFunctionDescriptor; +import org.jetbrains.jet.lang.resolve.constants.ConstantUtils; +import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstructor; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.jet.lang.types.*; @@ -356,6 +358,12 @@ public class CandidateResolver { if (dataFlowInfoForValueArgument != null) { newContext = newContext.replaceDataFlowInfo(dataFlowInfoForValueArgument); } + if (type != null && !type.getConstructor().isDenotable()) { + if (type.getConstructor() instanceof NumberValueTypeConstructor) { + NumberValueTypeConstructor constructor = (NumberValueTypeConstructor) type.getConstructor(); + type = ConstantUtils.updateConstantValueType(constructor, expectedType, expression, context); + } + } DataFlowUtils.checkType(type, expression, newContext); continue; } @@ -655,7 +663,7 @@ public class CandidateResolver { List variants = AutoCastUtils.getAutoCastVariants(context.trace.getBindingContext(), context.dataFlowInfo, receiverToCast); for (ReceiverValue receiverValue : variants) { JetType possibleType = receiverValue.getType(); - if (ArgumentTypeResolver.isSubtypeOfForArgumentType(possibleType, expectedType)) { + if (JetTypeChecker.INSTANCE.isSubtypeOf(possibleType, expectedType)) { return possibleType; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintsUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintsUtil.java index b37bedf1966..a8314231f6c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintsUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintsUtil.java @@ -16,16 +16,17 @@ package org.jetbrains.jet.lang.resolve.calls.inference; -import com.google.common.base.Predicate; -import com.google.common.collect.Collections2; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Sets; +import com.intellij.openapi.util.Pair; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; +import org.jetbrains.jet.lang.resolve.constants.NumberValueTypeConstructor; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.*; @@ -34,54 +35,124 @@ public class ConstraintsUtil { @NotNull public static Set getValues(@Nullable TypeConstraints typeConstraints) { Set values = Sets.newLinkedHashSet(); - if (typeConstraints != null && !typeConstraints.isEmpty()) { - if (typeConstraints.getExactBounds().size() == 1) { - if (verifyOneExactBound(typeConstraints)) { - JetType exactBound = typeConstraints.getExactBounds().iterator().next(); - return Collections.singleton(exactBound); + if (typeConstraints == null || typeConstraints.isEmpty()) { + return values; + } + TypeConstraints typeConstraintsWithoutErrorTypes = filterNotContainingErrorType(typeConstraints, values); + Collection exactBounds = typeConstraintsWithoutErrorTypes.getExactBounds(); + if (exactBounds.size() == 1) { + JetType exactBound = exactBounds.iterator().next(); + if (trySuggestion(exactBound, typeConstraints)) { + return Collections.singleton(exactBound); + } + } + values.addAll(exactBounds); + + Collection lowerBounds = Sets.newHashSet(); + Collection numberLowerBounds = Sets.newHashSet(); + for (JetType lowerBound : typeConstraintsWithoutErrorTypes.getLowerBounds()) { + if (lowerBound.getConstructor() instanceof NumberValueTypeConstructor) { + numberLowerBounds.add(lowerBound); + } + else { + lowerBounds.add(lowerBound); + } + } + JetType superTypeOfLowerBounds = commonSupertype(lowerBounds); + if (trySuggestion(superTypeOfLowerBounds, typeConstraints)) { + return Collections.singleton(superTypeOfLowerBounds); + } + addToValuesIfDifferent(superTypeOfLowerBounds, values); + + if (values.isEmpty()) { + Collection upperBounds = typeConstraintsWithoutErrorTypes.getUpperBounds(); + for (JetType upperBound : upperBounds) { + if (trySuggestion(upperBound, typeConstraints)) { + return Collections.singleton(upperBound); } } - values.addAll(typeConstraints.getExactBounds()); - Collection lowerBounds = filterNotContainingErrorType(typeConstraints.getLowerBounds()); - if (!lowerBounds.isEmpty()) { - JetType superTypeOfLowerBounds = CommonSupertypes.commonSupertype(lowerBounds); - for (JetType value : values) { - if (!JetTypeChecker.INSTANCE.isSubtypeOf(superTypeOfLowerBounds, value)) { - values.add(superTypeOfLowerBounds); - break; - } - } - if (values.isEmpty()) { - values.add(superTypeOfLowerBounds); - } - } - Collection upperBounds = filterNotContainingErrorType(typeConstraints.getUpperBounds()); - if (!upperBounds.isEmpty()) { - //todo subTypeOfUpperBounds - JetType subTypeOfUpperBounds = upperBounds.iterator().next(); //todo - for (JetType value : values) { - if (!JetTypeChecker.INSTANCE.isSubtypeOf(value, subTypeOfUpperBounds)) { - values.add(subTypeOfUpperBounds); - break; - } - } - if (values.isEmpty()) { - values.add(subTypeOfUpperBounds); - } + } + + for (JetType upperBound : typeConstraintsWithoutErrorTypes.getUpperBounds()) { + addToValuesIfDifferent(upperBound, values); + } + + JetType superTypeOfNumberLowerBounds = commonSupertypeForNumberTypes(numberLowerBounds); + if (trySuggestion(superTypeOfNumberLowerBounds, typeConstraints)) { + return Collections.singleton(superTypeOfNumberLowerBounds); + } + addToValuesIfDifferent(superTypeOfNumberLowerBounds, values); + + if (superTypeOfLowerBounds != null && superTypeOfNumberLowerBounds != null) { + JetType superTypeOfAllLowerBounds = + commonSupertype(Lists.newArrayList(superTypeOfLowerBounds, superTypeOfNumberLowerBounds)); + if (trySuggestion(superTypeOfAllLowerBounds, typeConstraints)) { + return Collections.singleton(superTypeOfAllLowerBounds); } } return values; } - private static boolean verifyOneExactBound(@NotNull TypeConstraints typeConstraints) { - JetType exactBound = typeConstraints.getExactBounds().iterator().next(); + private static void addToValuesIfDifferent(@Nullable JetType type, @NotNull Set values) { + if (type == null) return; + if (values.isEmpty()) { + values.add(type); + return; + } + for (JetType value : values) { + if (!JetTypeChecker.INSTANCE.equalTypes(type, value)) { + values.add(type); + return; + } + } + } + + @Nullable + private static JetType commonSupertype(@NotNull Collection lowerBounds) { + if (lowerBounds.isEmpty()) return null; + return CommonSupertypes.commonSupertype(lowerBounds); + } + + @Nullable + private static JetType commonSupertypeForNumberTypes(@NotNull Collection numberLowerBounds) { + if (numberLowerBounds.isEmpty()) return null; + Set numbers = Sets.newHashSet(); + for (JetType numberLowerBound : numberLowerBounds) { + assert numberLowerBound.getConstructor() instanceof NumberValueTypeConstructor; + numbers.add(((NumberValueTypeConstructor) numberLowerBound.getConstructor()).getValue()); + } + assert !numbers.isEmpty(); + return getDefaultNumberType(numbers); + } + + private static JetType getDefaultNumberType(Collection values) { + for (Long value : values) { + if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) { + return KotlinBuiltIns.getInstance().getLongType(); + } + } + return KotlinBuiltIns.getInstance().getIntType(); + } + + private static boolean trySuggestion( + @Nullable JetType suggestion, + @NotNull TypeConstraints typeConstraints + ) { + if (suggestion == null) return false; + if (typeConstraints.getExactBounds().size() > 1) return false; + + for (JetType exactBound : typeConstraints.getExactBounds()) { + if (!JetTypeChecker.INSTANCE.equalTypes(exactBound, suggestion)) { + return false; + } + } for (JetType lowerBound : typeConstraints.getLowerBounds()) { - if (!JetTypeChecker.INSTANCE.isSubtypeOf(lowerBound, exactBound)) { + if (!JetTypeChecker.INSTANCE.isSubtypeOf(lowerBound, suggestion)) { return false; } } for (JetType upperBound : typeConstraints.getUpperBounds()) { - if (!JetTypeChecker.INSTANCE.isSubtypeOf(exactBound, upperBound)) { + if (!JetTypeChecker.INSTANCE.isSubtypeOf(suggestion, upperBound)) { return false; } } @@ -89,14 +160,23 @@ public class ConstraintsUtil { } @NotNull - private static Collection filterNotContainingErrorType(@NotNull Collection types) { - return Collections2.filter(types, new Predicate() { - @Override - public boolean apply(@Nullable JetType type) { - if (ErrorUtils.containsErrorType(type)) return false; - return true; + private static TypeConstraints filterNotContainingErrorType( + @NotNull TypeConstraints typeConstraints, + @NotNull Collection values + ) { + TypeConstraintsImpl typeConstraintsWithoutErrorType = new TypeConstraintsImpl(typeConstraints.getVarianceOfPosition()); + Collection> allBounds = ((TypeConstraintsImpl) typeConstraints).getAllBounds(); + for (Pair pair : allBounds) { + TypeConstraintsImpl.BoundKind boundKind = pair.getFirst(); + JetType type = pair.getSecond(); + if (ErrorUtils.containsErrorType(type)) { + values.add(type); } - }); + else { + typeConstraintsWithoutErrorType.addBound(boundKind, type); + } + } + return typeConstraintsWithoutErrorType; } @Nullable diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/TypeConstraintsImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/TypeConstraintsImpl.java index 58b5f23bd13..be1071fc754 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/TypeConstraintsImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/TypeConstraintsImpl.java @@ -16,11 +16,14 @@ package org.jetbrains.jet.lang.resolve.calls.inference; +import com.google.common.collect.Lists; import com.google.common.collect.Sets; +import com.intellij.openapi.util.Pair; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.Variance; +import java.util.Collection; import java.util.Set; public class TypeConstraintsImpl implements TypeConstraints { @@ -86,4 +89,18 @@ public class TypeConstraintsImpl implements TypeConstraints { public static enum BoundKind { LOWER_BOUND, UPPER_BOUND, EXACT_BOUND } + + public Collection> getAllBounds() { + Collection> result = Lists.newArrayList(); + for (JetType exactBound : exactBounds) { + result.add(Pair.create(BoundKind.EXACT_BOUND, exactBound)); + } + for (JetType exactBound : upperBounds) { + result.add(Pair.create(BoundKind.UPPER_BOUND, exactBound)); + } + for (JetType exactBound : lowerBounds) { + result.add(Pair.create(BoundKind.LOWER_BOUND, exactBound)); + } + return result; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NumberValueTypeConstructor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NumberValueTypeConstructor.java index 5c8ce8038b2..0346480d483 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NumberValueTypeConstructor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NumberValueTypeConstructor.java @@ -16,25 +16,37 @@ 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.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeConstructor; -import org.jetbrains.jet.lang.types.TypeProjection; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.Collection; import java.util.Collections; import java.util.List; public class NumberValueTypeConstructor implements TypeConstructor { - private final Long value; + private final long value; + private final Collection supertypes = Lists.newArrayList(); - public NumberValueTypeConstructor(Long value) { + public NumberValueTypeConstructor(long value) { this.value = value; + + checkBoundsAndSuperType((long)Byte.MIN_VALUE, (long)Byte.MAX_VALUE, KotlinBuiltIns.getInstance().getByteType()); + checkBoundsAndSuperType((long)Short.MIN_VALUE, (long)Short.MAX_VALUE, KotlinBuiltIns.getInstance().getShortType()); + checkBoundsAndSuperType((long)Integer.MIN_VALUE, (long)Integer.MAX_VALUE, KotlinBuiltIns.getInstance().getIntType()); + supertypes.add(KotlinBuiltIns.getInstance().getLongType()); + } + + private void checkBoundsAndSuperType(long minValue, long maxValue, JetType kotlinType) { + if (value > minValue && value < maxValue) { + supertypes.add(kotlinType); + } } public Long getValue() { @@ -44,18 +56,18 @@ public class NumberValueTypeConstructor implements TypeConstructor { @NotNull @Override public List getParameters() { - throw new IllegalStateException(); + return Collections.emptyList(); } @NotNull @Override public Collection getSupertypes() { - throw new IllegalStateException(); + return supertypes; } @Override public boolean isSealed() { - throw new IllegalStateException(); + return false; } @Override @@ -66,12 +78,12 @@ public class NumberValueTypeConstructor implements TypeConstructor { @Nullable @Override public ClassifierDescriptor getDeclarationDescriptor() { - throw new IllegalStateException(); + return null; } @Override public List getAnnotations() { - throw new IllegalStateException(); + return Collections.emptyList(); } @Override @@ -79,15 +91,20 @@ public class NumberValueTypeConstructor implements TypeConstructor { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; - NumberValueTypeConstructor type = (NumberValueTypeConstructor) o; + NumberValueTypeConstructor that = (NumberValueTypeConstructor) o; - if (!value.equals(type.value)) return false; + if (value != that.value) return false; return true; } @Override public int hashCode() { - return value.hashCode(); + return (int) (value ^ (value >>> 32)); + } + + @Override + public String toString() { + return "NumberValueTypeConstructor(" + value + ')'; } } diff --git a/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt new file mode 100644 index 00000000000..dc09d2da90a --- /dev/null +++ b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt @@ -0,0 +1,66 @@ +package a + +fun id(t: T): T = t + +fun either(t1: T, t2: T): T = t1 + +fun other(s: String) {} + +fun otherGeneric(l: List) {} + +fun test() { + val a: Byte = id(1) + + val b: Byte = id(300) + + val c: Int = id(9223372036854775807) + + val d = id(22) + d: Int + + val e = id(9223372036854775807) + e: Int + e: Long + + val f: Byte = either(1, 2) + + val g: Byte = either(1, 300) + + other(11) + + otherGeneric(1) + + val r = either(1, "") + r: Int + r: String + r: Any +} + +trait Inv + +fun exactBound(t: T, l: Inv) {} + +fun testExactBound(invS: Inv, invI: Inv) { + exactBound(1, invS) + exactBound(1, invI) +} + +trait Cov + +fun lowerBound(t: T, l: Cov) = t + +fun testLowerBound(cov: Cov) { + val r = lowerBound(1, cov) + r: Any +} + +trait Contr + +fun upperBound(t: T, l: Contr) = t + +fun testUpperBound(contrS: Contr, contrB: Contr, contrN: Contr) { + upperBound(1, contrS) + + upperBound(1, contrN) + upperBound(1, contrB) +} diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index d6e38cf097a..edb06552586 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -33,7 +33,7 @@ import org.jetbrains.jet.checkers.AbstractDiagnosticsTestWithEagerResolve; @InnerTestClasses({JetDiagnosticsTestGenerated.Tests.class, JetDiagnosticsTestGenerated.Script.class}) public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEagerResolve { @TestMetadata("compiler/testData/diagnostics/tests") - @InnerTestClasses({Tests.Annotations.class, Tests.BackingField.class, Tests.CallableReference.class, Tests.Cast.class, Tests.CheckArguments.class, Tests.ControlFlowAnalysis.class, Tests.ControlStructures.class, Tests.DataClasses.class, Tests.DataFlow.class, Tests.DataFlowInfoTraversal.class, Tests.DeclarationChecks.class, Tests.DelegatedProperty.class, Tests.Deparenthesize.class, Tests.Enum.class, Tests.Extensions.class, Tests.FunctionLiterals.class, Tests.Generics.class, Tests.IncompleteCode.class, Tests.Inference.class, Tests.Infos.class, Tests.Inner.class, Tests.J_k.class, Tests.Jdk_annotations.class, Tests.Library.class, Tests.NullabilityAndAutoCasts.class, Tests.NullableTypes.class, Tests.Objects.class, Tests.OperatorsOverloading.class, Tests.Overload.class, Tests.Override.class, Tests.Recovery.class, Tests.Redeclarations.class, Tests.Regressions.class, Tests.Resolve.class, Tests.Scopes.class, Tests.SenselessComparison.class, Tests.Shadowing.class, Tests.SmartCasts.class, Tests.Substitutions.class, Tests.Subtyping.class, Tests.ThisAndSuper.class, Tests.Varargs.class}) + @InnerTestClasses({Tests.Annotations.class, Tests.BackingField.class, Tests.CallableReference.class, Tests.Cast.class, Tests.CheckArguments.class, Tests.ControlFlowAnalysis.class, Tests.ControlStructures.class, Tests.DataClasses.class, Tests.DataFlow.class, Tests.DataFlowInfoTraversal.class, Tests.DeclarationChecks.class, Tests.DelegatedProperty.class, Tests.Deparenthesize.class, Tests.Enum.class, Tests.Extensions.class, Tests.FunctionLiterals.class, Tests.Generics.class, Tests.IncompleteCode.class, Tests.Inference.class, Tests.Infos.class, Tests.Inner.class, Tests.J_k.class, Tests.Jdk_annotations.class, Tests.Library.class, Tests.NullabilityAndAutoCasts.class, Tests.NullableTypes.class, Tests.Numbers.class, Tests.Objects.class, Tests.OperatorsOverloading.class, Tests.Overload.class, Tests.Override.class, Tests.Recovery.class, Tests.Redeclarations.class, Tests.Regressions.class, Tests.Resolve.class, Tests.Scopes.class, Tests.SenselessComparison.class, Tests.Shadowing.class, Tests.SmartCasts.class, Tests.Substitutions.class, Tests.Subtyping.class, Tests.ThisAndSuper.class, Tests.Varargs.class}) public static class Tests extends AbstractDiagnosticsTestWithEagerResolve { @TestMetadata("Abstract.kt") public void testAbstract() throws Exception { @@ -3778,6 +3778,19 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage } + @TestMetadata("compiler/testData/diagnostics/tests/numbers") + public static class Numbers extends AbstractDiagnosticsTestWithEagerResolve { + public void testAllFilesPresentInNumbers() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/diagnostics/tests/numbers"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("numbersInSimpleConstraints.kt") + public void testNumbersInSimpleConstraints() throws Exception { + doTest("compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt"); + } + + } + @TestMetadata("compiler/testData/diagnostics/tests/objects") public static class Objects extends AbstractDiagnosticsTestWithEagerResolve { public void testAllFilesPresentInObjects() throws Exception { @@ -5305,6 +5318,7 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage suite.addTestSuite(Library.class); suite.addTestSuite(NullabilityAndAutoCasts.class); suite.addTestSuite(NullableTypes.class); + suite.addTestSuite(Numbers.class); suite.addTestSuite(Objects.class); suite.addTestSuite(OperatorsOverloading.class); suite.addTestSuite(Overload.class);