From cd28b216c17f59a835323d093616be34f6f0b15d Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Mon, 23 Jun 2014 15:34:13 +0400 Subject: [PATCH] Rename. INSTANCE -> DEFAULT in JetTypeChecker --- .../org/jetbrains/jet/codegen/ExpressionCodegen.java | 2 +- .../jet/codegen/ImplementationBodyCodegen.java | 2 +- .../AlternativeMethodSignatureData.java | 2 +- .../java/kotlinSignature/PropagationHeuristics.java | 4 ++-- .../jetbrains/jet/lang/cfg/pseudocode/TypePredicate.kt | 6 +++--- .../jet/lang/diagnostics/rendering/Renderers.java | 6 +++--- .../jet/lang/resolve/DeclarationsChecker.java | 4 ++-- .../jet/lang/resolve/DelegatedPropertyResolver.java | 2 +- .../jetbrains/jet/lang/resolve/DescriptorResolver.java | 4 ++-- .../org/jetbrains/jet/lang/resolve/OverloadUtil.java | 2 +- .../jetbrains/jet/lang/resolve/OverrideResolver.java | 4 ++-- .../jet/lang/resolve/calls/ArgumentTypeResolver.java | 2 +- .../jet/lang/resolve/calls/CandidateResolver.java | 4 ++-- .../lang/resolve/calls/autocasts/AutoCastUtils.java | 2 +- .../lang/resolve/calls/inference/ConstraintsUtil.java | 2 +- .../calls/results/OverloadingConflictResolver.java | 2 +- .../jet/lang/resolve/calls/tasks/TaskPrioritizer.java | 3 +-- .../resolve/constants/CompileTimeConstantChecker.java | 8 ++++---- .../jetbrains/jet/lang/types/CastDiagnosticsUtil.java | 6 +++--- .../expressions/BasicExpressionTypingVisitor.java | 4 ++-- .../expressions/ClosureExpressionsTypingVisitor.java | 4 ++-- .../expressions/ControlStructureTypingVisitor.java | 2 +- .../jet/lang/types/expressions/DataFlowUtils.java | 4 ++-- .../lang/types/expressions/ExpressionTypingUtils.java | 4 ++-- .../expressions/PatternMatchingTypingVisitor.java | 4 ++-- .../org/jetbrains/jet/plugin/MainFunctionDetector.java | 2 +- .../org/jetbrains/jet/types/JetTypeCheckerTest.java | 4 ++-- .../java/lazy/descriptors/LazyJavaClassDescriptor.kt | 2 +- .../resolve/java/lazy/types/LazyJavaTypeResolver.kt | 4 ++-- .../impl/AbstractTypeParameterDescriptor.java | 2 +- .../jetbrains/jet/lang/resolve/DescriptorUtils.java | 2 +- .../org/jetbrains/jet/lang/resolve/OverridingUtil.java | 10 +++++----- .../lang/resolve/calls/inference/TypeBoundsImpl.java | 8 ++++---- .../jet/lang/resolve/scopes/WritableScopeImpl.java | 2 +- .../org/jetbrains/jet/lang/types/AbstractJetType.java | 2 +- .../org/jetbrains/jet/lang/types/CommonSupertypes.java | 2 +- .../src/org/jetbrains/jet/lang/types/TypeUtils.java | 6 +++--- .../jet/lang/types/checker/JetTypeChecker.java | 2 +- .../org/jetbrains/jet/plugin/completion/smart/Utils.kt | 2 +- .../ReplaceContainsIntention.kt | 2 +- .../parameterInfo/JetFunctionParameterInfoHandler.java | 2 +- .../jet/plugin/quickfix/AddFunctionParametersFix.java | 2 +- .../jet/plugin/quickfix/AddFunctionToSupertypeFix.java | 4 ++-- .../jet/plugin/quickfix/AddNameToArgumentFix.java | 2 +- .../jet/plugin/quickfix/CastExpressionFix.java | 2 +- .../quickfix/ChangeFunctionLiteralReturnTypeFix.java | 6 +++--- .../plugin/quickfix/ChangeFunctionReturnTypeFix.java | 2 +- .../plugin/quickfix/ChangeFunctionSignatureFix.java | 2 +- .../quickfix/ChangeMemberFunctionSignatureFix.java | 2 +- .../jet/plugin/quickfix/ChangeVariableTypeFix.java | 6 +++--- .../jet/plugin/quickfix/CreateFunctionFromUsageFix.kt | 6 +++--- .../jetbrains/jet/plugin/quickfix/QuickFixUtil.java | 4 ++-- .../jet/plugin/refactoring/JetNameSuggester.java | 2 +- .../jet/plugin/refactoring/JetRefactoringUtil.java | 2 +- .../KotlinIntroduceVariableHandler.java | 7 ++----- 55 files changed, 94 insertions(+), 98 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 3624ea3bb2a..60cbe9f7dcc 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -722,7 +722,7 @@ public class ExpressionCodegen extends JetVisitor implem invokeFunction(fakeCall, StackValue.local(iteratorVarIndex, asmTypeForIterator), hasNextCall); JetType type = hasNextCall.getResultingDescriptor().getReturnType(); - assert type != null && JetTypeChecker.INSTANCE.isSubtypeOf(type, KotlinBuiltIns.getInstance().getBooleanType()); + assert type != null && JetTypeChecker.DEFAULT.isSubtypeOf(type, KotlinBuiltIns.getInstance().getBooleanType()); Type asmType = asmType(type); StackValue.coerce(asmType, Type.BOOLEAN_TYPE, v); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 8adcd8e19e0..15ef11f2960 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -484,7 +484,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { JetType returnType = function.getReturnType(); assert returnType != null : function.toString(); JetType paramType = function.getValueParameters().get(0).getType(); - if (JetTypeChecker.INSTANCE.equalTypes(arrayType, returnType) && JetTypeChecker.INSTANCE.equalTypes(arrayType, paramType)) { + if (JetTypeChecker.DEFAULT.equalTypes(arrayType, returnType) && JetTypeChecker.DEFAULT.equalTypes(arrayType, paramType)) { return true; } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java index 924c8f87f20..81f2e67463f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java @@ -139,7 +139,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD JetType substitutedReturnType = substitutor.substitute(returnType, Variance.INVARIANT); assert substitutedReturnType != null; - if (!JetTypeChecker.INSTANCE.isSubtypeOf(altReturnType, substitutedReturnType)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(altReturnType, substitutedReturnType)) { throw new AlternativeSignatureMismatchException( "Return type is changed to not subtype for method which overrides another: " + altReturnType + ", was: " + returnType); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java index f8ba53037cc..b8a0da70239 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/PropagationHeuristics.java @@ -59,8 +59,8 @@ class PropagationHeuristics { JetType elementTypeInSuper = arrayTypeFromSuper.getArguments().get(0).getType(); JetType elementType = type.getArguments().get(0).getType(); - if (JetTypeChecker.INSTANCE.isSubtypeOf(elementType, elementTypeInSuper) - && !JetTypeChecker.INSTANCE.equalTypes(elementType, elementTypeInSuper)) { + if (JetTypeChecker.DEFAULT.isSubtypeOf(elementType, elementTypeInSuper) + && !JetTypeChecker.DEFAULT.equalTypes(elementType, elementTypeInSuper)) { JetTypeImpl betterTypeInSuper = new JetTypeImpl( arrayTypeFromSuper.getAnnotations(), arrayTypeFromSuper.getConstructor(), diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/TypePredicate.kt b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/TypePredicate.kt index 60aea47a0e1..04b8eb99a64 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/TypePredicate.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/TypePredicate.kt @@ -28,12 +28,12 @@ public trait TypePredicate: (JetType) -> Boolean { } public data class SingleType(val targetType: JetType): TypePredicate { - override fun invoke(typeToCheck: JetType): Boolean = JetTypeChecker.INSTANCE.equalTypes(typeToCheck, targetType) + override fun invoke(typeToCheck: JetType): Boolean = JetTypeChecker.DEFAULT.equalTypes(typeToCheck, targetType) override fun toString(): String = targetType.render() } public data class AllSubtypes(val upperBound: JetType): TypePredicate { - override fun invoke(typeToCheck: JetType): Boolean = JetTypeChecker.INSTANCE.isSubtypeOf(typeToCheck, upperBound) + override fun invoke(typeToCheck: JetType): Boolean = JetTypeChecker.DEFAULT.isSubtypeOf(typeToCheck, upperBound) override fun toString(): String = "{<: ${upperBound.render()}}" } @@ -72,7 +72,7 @@ fun or(predicates: Collection): TypePredicate? = } fun JetType.getSubtypesPredicate(): TypePredicate? = - if (TypeUtils.canHaveSubtypes(JetTypeChecker.INSTANCE, this)) AllSubtypes(this) else SingleType(this) + if (TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, this)) AllSubtypes(this) else SingleType(this) private fun JetType.render(): String = DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(this) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java index 0bf808a306e..72d3d2b52da 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/Renderers.java @@ -229,13 +229,13 @@ public class Renderers { parameterTypes.add(valueParameterDescriptor.getType()); if (valueParameterDescriptor.getIndex() >= inferenceErrorData.valueArgumentsTypes.size()) continue; JetType actualType = inferenceErrorData.valueArgumentsTypes.get(valueParameterDescriptor.getIndex()); - if (!JetTypeChecker.INSTANCE.isSubtypeOf(actualType, valueParameterDescriptor.getType())) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(actualType, valueParameterDescriptor.getType())) { errorPositions.add(ConstraintPosition.getValueParameterPosition(valueParameterDescriptor.getIndex())); } } if (receiverType != null && inferenceErrorData.receiverArgumentType != null && - !JetTypeChecker.INSTANCE.isSubtypeOf(inferenceErrorData.receiverArgumentType, receiverType)) { + !JetTypeChecker.DEFAULT.isSubtypeOf(inferenceErrorData.receiverArgumentType, receiverType)) { errorPositions.add(ConstraintPosition.RECEIVER_POSITION); } @@ -333,7 +333,7 @@ public class Renderers { JetType upperBoundWithSubstitutedInferredTypes = systemWithoutWeakConstraints.getResultingSubstitutor().substitute(upperBound, Variance.INVARIANT); if (upperBoundWithSubstitutedInferredTypes != null && - !JetTypeChecker.INSTANCE.isSubtypeOf(inferredValueForTypeParameter, upperBoundWithSubstitutedInferredTypes)) { + !JetTypeChecker.DEFAULT.isSubtypeOf(inferredValueForTypeParameter, upperBoundWithSubstitutedInferredTypes)) { violatedUpperBound = upperBoundWithSubstitutedInferredTypes; break; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java index a07420658a7..8c4c3bd712c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java @@ -220,13 +220,13 @@ public class DeclarationsChecker { REMOVE_IF_SUBTYPE_IN_THE_SET { @Override public boolean removeNeeded(JetType subject, JetType other) { - return JetTypeChecker.INSTANCE.isSubtypeOf(other, subject); + return JetTypeChecker.DEFAULT.isSubtypeOf(other, subject); } }, REMOVE_IF_SUPERTYPE_IN_THE_SET { @Override public boolean removeNeeded(JetType subject, JetType other) { - return JetTypeChecker.INSTANCE.isSubtypeOf(subject, other); + return JetTypeChecker.DEFAULT.isSubtypeOf(subject, other); } }; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java index 3cc288d0deb..327a1c81b5d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatedPropertyResolver.java @@ -98,7 +98,7 @@ public class DelegatedPropertyResolver { JetType propertyType = propertyDescriptor.getType(); /* Do not check return type of get() method of delegate for properties with DeferredType because property type is taken from it */ - if (!(propertyType instanceof DeferredType) && returnType != null && !JetTypeChecker.INSTANCE.isSubtypeOf(returnType, propertyType)) { + if (!(propertyType instanceof DeferredType) && returnType != null && !JetTypeChecker.DEFAULT.isSubtypeOf(returnType, propertyType)) { Call call = trace.getBindingContext().get(DELEGATED_PROPERTY_CALL, propertyDescriptor.getGetter()); assert call != null : "Call should exists for " + propertyDescriptor.getGetter(); trace.report(DELEGATE_SPECIAL_FUNCTION_RETURN_TYPE_MISMATCH diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java index c5f96ec1e87..9afc4b1a47a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -760,7 +760,7 @@ public class DescriptorResolver { boolean isClassObjectConstraint, BindingTrace trace ) { - if (!TypeUtils.canHaveSubtypes(JetTypeChecker.INSTANCE, upperBoundType)) { + if (!TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, upperBoundType)) { if (isClassObjectConstraint) { trace.report(FINAL_CLASS_OBJECT_UPPER_BOUND.on(upperBound, upperBoundType)); } @@ -1360,7 +1360,7 @@ public class DescriptorResolver { ) { for (JetType bound : typeParameterDescriptor.getUpperBounds()) { JetType substitutedBound = substitutor.safeSubstitute(bound, Variance.INVARIANT); - if (!JetTypeChecker.INSTANCE.isSubtypeOf(typeArgument, substitutedBound)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(typeArgument, substitutedBound)) { trace.report(UPPER_BOUND_VIOLATED.on(jetTypeArgument, substitutedBound, typeArgument)); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java index 6eccea98512..8bf3e2fc931 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java @@ -71,7 +71,7 @@ public class OverloadUtil { JetType superValueParameterType = OverridingUtil.getUpperBound(superValueParameters.get(i)); JetType subValueParameterType = OverridingUtil.getUpperBound(subValueParameters.get(i)); // TODO: compare erasure - if (!JetTypeChecker.INSTANCE.equalTypes(superValueParameterType, subValueParameterType)) { + if (!JetTypeChecker.DEFAULT.equalTypes(superValueParameterType, subValueParameterType)) { return OverridingUtil.OverrideCompatibilityInfo .valueParameterTypeMismatch(superValueParameterType, subValueParameterType, INCOMPATIBLE); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index 2b091f3459f..e5b1be44da5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -733,7 +733,7 @@ public class OverrideResolver { JetType substitutedSuperReturnType = typeSubstitutor.substitute(superReturnType, Variance.OUT_VARIANCE); assert substitutedSuperReturnType != null; - return JetTypeChecker.INSTANCE.isSubtypeOf(subReturnType, substitutedSuperReturnType); + return JetTypeChecker.DEFAULT.isSubtypeOf(subReturnType, substitutedSuperReturnType); } @Nullable @@ -768,7 +768,7 @@ public class OverrideResolver { JetType substitutedSuperReturnType = typeSubstitutor.substitute(superDescriptor.getType(), Variance.OUT_VARIANCE); assert substitutedSuperReturnType != null; - return JetTypeChecker.INSTANCE.equalTypes(subDescriptor.getType(), substitutedSuperReturnType); + return JetTypeChecker.DEFAULT.equalTypes(subDescriptor.getType(), substitutedSuperReturnType); } private void checkOverrideForComponentFunction(@NotNull final CallableMemberDescriptor componentFunction) { 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 91f2d1d64e8..3eba4a8a729 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 @@ -74,7 +74,7 @@ public class ArgumentTypeResolver { if (actualType == PLACEHOLDER_FUNCTION_TYPE) { return isFunctionOrErrorType(expectedType) || KotlinBuiltIns.getInstance().isAnyOrNullableAny(expectedType); //todo function type extends } - return JetTypeChecker.INSTANCE.isSubtypeOf(actualType, expectedType); + return JetTypeChecker.DEFAULT.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 1fb1f127305..2259350c967 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 @@ -735,7 +735,7 @@ public class CandidateResolver { Set possibleTypes = dataFlowInfoForArgument.getPossibleTypes(dataFlowValue); if (possibleTypes.isEmpty()) return type; - return TypeUtils.intersect(JetTypeChecker.INSTANCE, possibleTypes); + return TypeUtils.intersect(JetTypeChecker.DEFAULT, possibleTypes); } private ValueArgumentsCheckingResult checkAllValueArguments( @@ -859,7 +859,7 @@ public class CandidateResolver { List variants = AutoCastUtils.getAutoCastVariantsExcludingReceiver(context.trace.getBindingContext(), context.dataFlowInfo, receiverToCast); for (JetType possibleType : variants) { - if (JetTypeChecker.INSTANCE.isSubtypeOf(possibleType, expectedType)) { + if (JetTypeChecker.DEFAULT.isSubtypeOf(possibleType, expectedType)) { return possibleType; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastUtils.java index 2e6bdc26d93..4991d3c4785 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/AutoCastUtils.java @@ -116,7 +116,7 @@ public class AutoCastUtils { } if (subTypes.isEmpty()) return null; - JetType intersection = TypeUtils.intersect(JetTypeChecker.INSTANCE, subTypes); + JetType intersection = TypeUtils.intersect(JetTypeChecker.DEFAULT, subTypes); if (intersection == null || !intersection.getConstructor().isDenotable()) { return receiverParameterType; } 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 aec3e3562d3..ccaaaf8b12b 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 @@ -94,7 +94,7 @@ public class ConstraintsUtil { JetType substitutedUpperBound = constraintSystem.getResultingSubstitutor().substitute(upperBound, Variance.INVARIANT); assert substitutedUpperBound != null : "We wanted to substitute projections as a result for " + typeParameter; - if (!JetTypeChecker.INSTANCE.isSubtypeOf(type, substitutedUpperBound)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(type, substitutedUpperBound)) { return false; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java index 03901b7d70a..2bd6d32a3c8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java @@ -239,7 +239,7 @@ public class OverloadingConflictResolver { } private boolean typeMoreSpecific(@NotNull JetType specific, @NotNull JetType general) { - return JetTypeChecker.INSTANCE.isSubtypeOf(specific, general) || + return JetTypeChecker.DEFAULT.isSubtypeOf(specific, general) || numericTypeMoreSpecific(specific, general); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java index 39eb7ff3f84..5166f22bd2a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java @@ -25,7 +25,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.Call; import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.psi.JetSuperExpression; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastUtils; @@ -326,7 +325,7 @@ public class TaskPrioritizer { if (expectedThisObject == null) return true; List receivers = scope.getImplicitReceiversHierarchy(); for (ReceiverParameterDescriptor receiver : receivers) { - if (JetTypeChecker.INSTANCE.isSubtypeOf(receiver.getType(), expectedThisObject.getType())) { + if (JetTypeChecker.DEFAULT.isSubtypeOf(receiver.getType(), expectedThisObject.getType())) { // TODO : Autocasts & nullability candidate.setThisObject(expectedThisObject.getValue()); return true; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantChecker.java index ade5431b98a..58b04689557 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantChecker.java @@ -90,7 +90,7 @@ public class CompileTimeConstantChecker { if (!noExpectedTypeOrError(expectedType)) { JetType valueType = value.getType(KotlinBuiltIns.getInstance()); - if (!JetTypeChecker.INSTANCE.isSubtypeOf(valueType, expectedType)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) { return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "integer", expectedType)); } } @@ -107,7 +107,7 @@ public class CompileTimeConstantChecker { } if (!noExpectedTypeOrError(expectedType)) { JetType valueType = value.getType(KotlinBuiltIns.getInstance()); - if (!JetTypeChecker.INSTANCE.isSubtypeOf(valueType, expectedType)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(valueType, expectedType)) { return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "floating-point", expectedType)); } } @@ -119,7 +119,7 @@ public class CompileTimeConstantChecker { @NotNull JetConstantExpression expression ) { if (!noExpectedTypeOrError(expectedType) - && !JetTypeChecker.INSTANCE.isSubtypeOf(builtIns.getBooleanType(), expectedType)) { + && !JetTypeChecker.DEFAULT.isSubtypeOf(builtIns.getBooleanType(), expectedType)) { return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "boolean", expectedType)); } return false; @@ -127,7 +127,7 @@ public class CompileTimeConstantChecker { private boolean checkCharValue(CompileTimeConstant constant, JetType expectedType, JetConstantExpression expression) { if (!noExpectedTypeOrError(expectedType) - && !JetTypeChecker.INSTANCE.isSubtypeOf(builtIns.getCharType(), expectedType)) { + && !JetTypeChecker.DEFAULT.isSubtypeOf(builtIns.getCharType(), expectedType)) { return reportError(CONSTANT_EXPECTED_TYPE_MISMATCH.on(expression, "character", expectedType)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/CastDiagnosticsUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/CastDiagnosticsUtil.java index 95e8f484b89..e9032ba4682 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/CastDiagnosticsUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/CastDiagnosticsUtil.java @@ -66,8 +66,8 @@ public class CastDiagnosticsUtil { for (JetType aType : aTypes) { for (JetType bType : bTypes) { - if (JetTypeChecker.INSTANCE.isSubtypeOf(aType, bType)) return true; - if (JetTypeChecker.INSTANCE.isSubtypeOf(bType, aType)) return true; + if (JetTypeChecker.DEFAULT.isSubtypeOf(aType, bType)) return true; + if (JetTypeChecker.DEFAULT.isSubtypeOf(bType, aType)) return true; } } @@ -100,7 +100,7 @@ public class CastDiagnosticsUtil { } private static boolean isFinal(@NotNull JetType type) { - return !TypeUtils.canHaveSubtypes(JetTypeChecker.INSTANCE, type); + return !TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, type); } private static boolean isTrait(@NotNull JetType type) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index 0fb97d20f3f..edf331d8c97 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -212,7 +212,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { context.trace.report(CAST_NEVER_SUCCEEDS.on(expression.getOperationReference())); } else { - JetTypeChecker typeChecker = JetTypeChecker.INSTANCE; + JetTypeChecker typeChecker = JetTypeChecker.DEFAULT; // Upcast? if (typeChecker.isSubtypeOf(actualType, targetType)) { if (!typeChecker.isSubtypeOf(targetType, actualType)) { @@ -668,7 +668,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } else { JetType receiverType = receiver.getType(); - if (!JetTypeChecker.INSTANCE.isSubtypeOf(returnType, receiverType)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(returnType, receiverType)) { context.trace.report(RESULT_TYPE_MISMATCH.on(operationSign, name.asString(), receiverType, returnType)); } else { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 4bc6fd8baff..73331a549fb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -221,7 +221,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { if (typeReference != null) { type = components.expressionTypingServices.getTypeResolver().resolveType(context.scope, typeReference, context.trace, true); if (expectedType != null) { - if (!JetTypeChecker.INSTANCE.isSubtypeOf(expectedType, type)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(expectedType, type)) { context.trace.report(EXPECTED_PARAMETER_TYPE_MISMATCH.on(declaredParameter, expectedType)); } } @@ -278,7 +278,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { // This is needed for ControlStructureTypingVisitor#visitReturnExpression() to properly type-check returned expressions functionDescriptor.setReturnType(declaredReturnType); if (expectedReturnType != null) { - if (!JetTypeChecker.INSTANCE.isSubtypeOf(declaredReturnType, expectedReturnType)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(declaredReturnType, expectedReturnType)) { context.trace.report(EXPECTED_RETURN_TYPE_MISMATCH.on(returnTypeRef, expectedReturnType)); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index c8b74780ff3..e0ce8f2fcc5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java @@ -355,7 +355,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { variableDescriptor = components.expressionTypingServices.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope, loopParameter, context.trace); JetType actualParameterType = variableDescriptor.getType(); if (expectedParameterType != null && - !JetTypeChecker.INSTANCE.isSubtypeOf(expectedParameterType, actualParameterType)) { + !JetTypeChecker.DEFAULT.isSubtypeOf(expectedParameterType, actualParameterType)) { context.trace.report(TYPE_MISMATCH_IN_FOR_LOOP.on(typeReference, expectedParameterType, actualParameterType)); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java index 270f4d1cba7..d8bf889087c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/DataFlowUtils.java @@ -164,7 +164,7 @@ public class DataFlowUtils { recordExpectedType(trace, expression, expectedType); if (expressionType == null || noExpectedType(expectedType) || !expectedType.getConstructor().isDenotable() || - JetTypeChecker.INSTANCE.isSubtypeOf(expressionType, expectedType)) { + JetTypeChecker.DEFAULT.isSubtypeOf(expressionType, expectedType)) { return expressionType; } @@ -179,7 +179,7 @@ public class DataFlowUtils { DataFlowValue dataFlowValue = DataFlowValueFactory.createDataFlowValue(expression, expressionType, trace.getBindingContext()); for (JetType possibleType : dataFlowInfo.getPossibleTypes(dataFlowValue)) { - if (JetTypeChecker.INSTANCE.isSubtypeOf(possibleType, expectedType)) { + if (JetTypeChecker.DEFAULT.isSubtypeOf(possibleType, expectedType)) { AutoCastUtils.recordCastOrError(expression, possibleType, trace, dataFlowValue.isStableIdentifier(), false); return possibleType; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 852453f93cb..c56aee232cf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -96,7 +96,7 @@ public class ExpressionTypingUtils { } public static boolean isBoolean(@NotNull JetType type) { - return JetTypeChecker.INSTANCE.isSubtypeOf(type, KotlinBuiltIns.getInstance().getBooleanType()); + return JetTypeChecker.DEFAULT.isSubtypeOf(type, KotlinBuiltIns.getInstance().getBooleanType()); } public static boolean ensureBooleanResult(JetExpression operationSign, Name name, JetType resultType, ExpressionTypingContext context) { @@ -401,7 +401,7 @@ public class ExpressionTypingUtils { context.trace.record(COMPONENT_RESOLVED_CALL, entry, results.getResultingCall()); componentType = results.getResultingDescriptor().getReturnType(); if (componentType != null && !noExpectedType(expectedType) - && !JetTypeChecker.INSTANCE.isSubtypeOf(componentType, expectedType)) { + && !JetTypeChecker.DEFAULT.isSubtypeOf(componentType, expectedType)) { context.trace.report( COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH.on(reportErrorsOn, componentName, componentType, expectedType)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java index a3692734077..f9b036c492a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/PatternMatchingTypingVisitor.java @@ -254,7 +254,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { context = context.replaceDataFlowInfo(typeInfo.getDataFlowInfo()); if (conditionExpected) { JetType booleanType = KotlinBuiltIns.getInstance().getBooleanType(); - if (!JetTypeChecker.INSTANCE.equalTypes(booleanType, type)) { + if (!JetTypeChecker.DEFAULT.equalTypes(booleanType, type)) { context.trace.report(TYPE_MISMATCH_IN_CONDITION.on(expression, type)); } else { @@ -294,7 +294,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { context.trace.report(Errors.USELESS_NULLABLE_CHECK.on(nullableType)); } checkTypeCompatibility(context, type, subjectType, typeReferenceAfterIs); - if (CastDiagnosticsUtil.isCastErased(subjectType, type, JetTypeChecker.INSTANCE)) { + if (CastDiagnosticsUtil.isCastErased(subjectType, type, JetTypeChecker.DEFAULT)) { context.trace.report(Errors.CANNOT_CHECK_FOR_ERASED.on(typeReferenceAfterIs, type)); } return new DataFlowInfos(context.dataFlowInfo.establishSubtyping(subjectDataFlowValue, type), context.dataFlowInfo); diff --git a/compiler/frontend/src/org/jetbrains/jet/plugin/MainFunctionDetector.java b/compiler/frontend/src/org/jetbrains/jet/plugin/MainFunctionDetector.java index 46b9dcfff8f..33fb189f141 100644 --- a/compiler/frontend/src/org/jetbrains/jet/plugin/MainFunctionDetector.java +++ b/compiler/frontend/src/org/jetbrains/jet/plugin/MainFunctionDetector.java @@ -80,7 +80,7 @@ public class MainFunctionDetector { List typeArguments = parameterType.getArguments(); if (typeArguments.size() == 1) { JetType typeArgument = typeArguments.get(0).getType(); - if (JetTypeChecker.INSTANCE.equalTypes(typeArgument, kotlinBuiltIns.getStringType())) { + if (JetTypeChecker.DEFAULT.equalTypes(typeArgument, kotlinBuiltIns.getStringType())) { return true; } } diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 5899e002084..ae686135ce9 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -503,7 +503,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { for (String type : types) { typesToIntersect.add(makeType(type)); } - JetType result = TypeUtils.intersect(JetTypeChecker.INSTANCE, typesToIntersect); + JetType result = TypeUtils.intersect(JetTypeChecker.DEFAULT, typesToIntersect); // assertNotNull("Intersection is null for " + typesToIntersect, result); assertEquals(makeType(expected), result); } @@ -520,7 +520,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { private void assertSubtypingRelation(String subtype, String supertype, boolean expected) { JetType typeNode1 = makeType(subtype); JetType typeNode2 = makeType(supertype); - boolean result = JetTypeChecker.INSTANCE.isSubtypeOf( + boolean result = JetTypeChecker.DEFAULT.isSubtypeOf( typeNode1, typeNode2); String modifier = expected ? "not " : ""; diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt index 01be75b4317..80b1b5a09ec 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt @@ -181,7 +181,7 @@ class LazyJavaClassDescriptor( val candidateReturnType = candidate.getReturnType() val currentMostSpecificReturnType = currentMostSpecificType.getReturnType() assert(candidateReturnType != null && currentMostSpecificReturnType != null, "$candidate, $currentMostSpecificReturnType") - if (JetTypeChecker.INSTANCE.isSubtypeOf(candidateReturnType!!, currentMostSpecificReturnType!!)) { + if (JetTypeChecker.DEFAULT.isSubtypeOf(candidateReturnType!!, currentMostSpecificReturnType!!)) { currentMostSpecificType = candidate } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt index 25ca250653d..b9f46f376cb 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt @@ -147,7 +147,7 @@ class LazyJavaTypeResolver( for (supertype in (classifier() as JavaTypeParameter).getUpperBounds()) { supertypesJet.add(transformJavaType(supertype, UPPER_BOUND.toAttributes())) } - return TypeUtils.intersect(JetTypeChecker.INSTANCE, supertypesJet) + return TypeUtils.intersect(JetTypeChecker.DEFAULT, supertypesJet) ?: ErrorUtils.createErrorType("Can't intersect upper bounds of " + javaType.getPresentableText()) } @@ -276,4 +276,4 @@ fun TypeUsage.toAttributes() = object : JavaTypeAttributes { override val howThisTypeIsUsedAccordingToAnnotations: TypeUsage get() = howThisTypeIsUsed override val isMarkedNotNull: Boolean = false -} \ No newline at end of file +} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractTypeParameterDescriptor.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractTypeParameterDescriptor.java index 9be787d0c5b..07994b4070a 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractTypeParameterDescriptor.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractTypeParameterDescriptor.java @@ -132,7 +132,7 @@ public abstract class AbstractTypeParameterDescriptor extends DeclarationDescrip private JetType computeUpperBoundsAsType() { Set upperBounds = getUpperBounds(); assert !upperBounds.isEmpty() : "Upper bound list is empty in " + getName(); - JetType upperBoundsAsType = TypeUtils.intersect(JetTypeChecker.INSTANCE, upperBounds); + JetType upperBoundsAsType = TypeUtils.intersect(JetTypeChecker.DEFAULT, upperBounds); return upperBoundsAsType != null ? upperBoundsAsType : KotlinBuiltIns.getInstance().getNothingType(); } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index 6a51a1e1a1b..fd07e32b8ca 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -459,7 +459,7 @@ public class DescriptorUtils { JetType nullableString = TypeUtils.makeNullable(KotlinBuiltIns.getInstance().getStringType()); return "valueOf".equals(functionDescriptor.getName().asString()) && methodTypeParameters.size() == 1 - && JetTypeChecker.INSTANCE.isSubtypeOf(methodTypeParameters.get(0).getType(), nullableString); + && JetTypeChecker.DEFAULT.isSubtypeOf(methodTypeParameters.get(0).getType(), nullableString); } public static boolean isEnumValuesMethod(@NotNull FunctionDescriptor functionDescriptor) { diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java index f5e744d2da5..942ddd72841 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java @@ -113,7 +113,7 @@ public class OverridingUtil { JetType superValueParameterType = getUpperBound(superValueParameters.get(i)); JetType subValueParameterType = getUpperBound(subValueParameters.get(i)); // TODO: compare erasure - if (!JetTypeChecker.INSTANCE.equalTypes(superValueParameterType, subValueParameterType)) { + if (!JetTypeChecker.DEFAULT.equalTypes(superValueParameterType, subValueParameterType)) { return OverrideCompatibilityInfo.typeParameterNumberMismatch(); } } @@ -165,7 +165,7 @@ public class OverridingUtil { if (superReturnType != null && subReturnType != null) { boolean bothErrors = subReturnType.isError() && superReturnType.isError(); - if (!bothErrors && !JetTypeChecker.INSTANCE.isSubtypeOf(subReturnType, superReturnType, localEqualityAxioms)) { + if (!bothErrors && !JetTypeChecker.DEFAULT.isSubtypeOf(subReturnType, superReturnType, localEqualityAxioms)) { return OverrideCompatibilityInfo.returnTypeMismatch(superReturnType, subReturnType); } } @@ -203,7 +203,7 @@ public class OverridingUtil { @NotNull JetTypeChecker.TypeConstructorEquality axioms ) { boolean bothErrors = typeInSuper.isError() && typeInSub.isError(); - if (!bothErrors && !JetTypeChecker.INSTANCE.equalTypes(typeInSuper, typeInSub, axioms)) { + if (!bothErrors && !JetTypeChecker.DEFAULT.equalTypes(typeInSuper, typeInSub, axioms)) { return false; } return true; @@ -317,7 +317,7 @@ public class OverridingUtil { JetType bReturnType = b.getReturnType(); assert bReturnType != null; - return JetTypeChecker.INSTANCE.isSubtypeOf(aReturnType, bReturnType); + return JetTypeChecker.DEFAULT.isSubtypeOf(aReturnType, bReturnType); } if (a instanceof PropertyDescriptor) { assert b instanceof PropertyDescriptor : "b is " + b.getClass(); @@ -327,7 +327,7 @@ public class OverridingUtil { } // both vals - return JetTypeChecker.INSTANCE.isSubtypeOf(((PropertyDescriptor) a).getType(), ((PropertyDescriptor) b).getType()); + return JetTypeChecker.DEFAULT.isSubtypeOf(((PropertyDescriptor) a).getType(), ((PropertyDescriptor) b).getType()); } throw new IllegalArgumentException("Unexpected callable: " + a.getClass()); } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/calls/inference/TypeBoundsImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/calls/inference/TypeBoundsImpl.java index 20ef01fb9f0..cb08c23f4b7 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/calls/inference/TypeBoundsImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/calls/inference/TypeBoundsImpl.java @@ -197,7 +197,7 @@ public class TypeBoundsImpl implements TypeBounds { } Set upperBounds = filterBounds(bounds, BoundKind.UPPER_BOUND, values); - JetType intersectionOfUpperBounds = TypeUtils.intersect(JetTypeChecker.INSTANCE, upperBounds); + JetType intersectionOfUpperBounds = TypeUtils.intersect(JetTypeChecker.DEFAULT, upperBounds); if (!upperBounds.isEmpty() && intersectionOfUpperBounds != null) { if (tryPossibleAnswer(intersectionOfUpperBounds)) { return Collections.singleton(intersectionOfUpperBounds); @@ -216,19 +216,19 @@ public class TypeBoundsImpl implements TypeBounds { for (Bound bound : bounds) { switch (bound.kind) { case LOWER_BOUND: - if (!JetTypeChecker.INSTANCE.isSubtypeOf(bound.type, possibleAnswer)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(bound.type, possibleAnswer)) { return false; } break; case UPPER_BOUND: - if (!JetTypeChecker.INSTANCE.isSubtypeOf(possibleAnswer, bound.type)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(possibleAnswer, bound.type)) { return false; } break; case EXACT_BOUND: - if (!JetTypeChecker.INSTANCE.equalTypes(bound.type, possibleAnswer)) { + if (!JetTypeChecker.DEFAULT.equalTypes(bound.type, possibleAnswer)) { return false; } break; diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java index 4be5948ab9f..816fb52f8f3 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java @@ -352,7 +352,7 @@ public class WritableScopeImpl extends WritableScopeWithImports { for (VariableDescriptor oldProperty : properties) { ReceiverParameterDescriptor receiverParameterForOldVariable = oldProperty.getReceiverParameter(); if (((receiverParameter != null && receiverParameterForOldVariable != null) && - (JetTypeChecker.INSTANCE.equalTypes(receiverParameter.getType(), receiverParameterForOldVariable.getType())))) { + (JetTypeChecker.DEFAULT.equalTypes(receiverParameter.getType(), receiverParameterForOldVariable.getType())))) { redeclarationHandler.handleRedeclaration(oldProperty, variableDescriptor); } } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/AbstractJetType.java b/core/descriptors/src/org/jetbrains/jet/lang/types/AbstractJetType.java index d5ddee2fd74..4cbed4bca24 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/AbstractJetType.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/AbstractJetType.java @@ -37,7 +37,7 @@ public abstract class AbstractJetType implements JetType { JetType type = (JetType) obj; - return isNullable() == type.isNullable() && JetTypeChecker.INSTANCE.equalTypes(this, type); + return isNullable() == type.isNullable() && JetTypeChecker.DEFAULT.equalTypes(this, type); } @Override diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/CommonSupertypes.java b/core/descriptors/src/org/jetbrains/jet/lang/types/CommonSupertypes.java index 4c2eb28cd2c..100f56f3b9d 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/CommonSupertypes.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/CommonSupertypes.java @@ -216,7 +216,7 @@ public class CommonSupertypes { } if (ins != null) { - JetType intersection = TypeUtils.intersect(JetTypeChecker.INSTANCE, ins); + JetType intersection = TypeUtils.intersect(JetTypeChecker.DEFAULT, ins); if (intersection == null) { if (outs != null) { return new TypeProjectionImpl(OUT_VARIANCE, commonSupertype(outs)); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/TypeUtils.java b/core/descriptors/src/org/jetbrains/jet/lang/types/TypeUtils.java index 084f1b64deb..ecebe07b469 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/TypeUtils.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/TypeUtils.java @@ -142,7 +142,7 @@ public class TypeUtils { } public static boolean isIntersectionEmpty(@NotNull JetType typeA, @NotNull JetType typeB) { - return intersect(JetTypeChecker.INSTANCE, Sets.newLinkedHashSet(Lists.newArrayList(typeA, typeB))) == null; + return intersect(JetTypeChecker.DEFAULT, Sets.newLinkedHashSet(Lists.newArrayList(typeA, typeB))) == null; } @Nullable @@ -473,7 +473,7 @@ public class TypeUtils { } public static boolean equalTypes(@NotNull JetType a, @NotNull JetType b) { - return JetTypeChecker.INSTANCE.isSubtypeOf(a, b) && JetTypeChecker.INSTANCE.isSubtypeOf(b, a); + return JetTypeChecker.DEFAULT.isSubtypeOf(a, b) && JetTypeChecker.DEFAULT.isSubtypeOf(b, a); } public static boolean dependsOnTypeParameters(@NotNull JetType type, @NotNull Collection typeParameters) { @@ -586,7 +586,7 @@ public class TypeUtils { return getDefaultPrimitiveNumberType(numberValueTypeConstructor); } for (JetType primitiveNumberType : numberValueTypeConstructor.getSupertypes()) { - if (JetTypeChecker.INSTANCE.isSubtypeOf(primitiveNumberType, expectedType)) { + if (JetTypeChecker.DEFAULT.isSubtypeOf(primitiveNumberType, expectedType)) { return primitiveNumberType; } } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/checker/JetTypeChecker.java b/core/descriptors/src/org/jetbrains/jet/lang/types/checker/JetTypeChecker.java index 9c190e67c77..7f52422fc7b 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/checker/JetTypeChecker.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/checker/JetTypeChecker.java @@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.types.TypeConstructor; public class JetTypeChecker { - public static final JetTypeChecker INSTANCE = new JetTypeChecker(); + public static final JetTypeChecker DEFAULT = new JetTypeChecker(); public interface TypeConstructorEquality { boolean equals(@NotNull TypeConstructor a, @NotNull TypeConstructor b); } diff --git a/idea/src/org/jetbrains/jet/plugin/completion/smart/Utils.kt b/idea/src/org/jetbrains/jet/plugin/completion/smart/Utils.kt index 7300d4bf674..ebc4e640e5d 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/smart/Utils.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/smart/Utils.kt @@ -172,7 +172,7 @@ fun createLookupElement(descriptor: DeclarationDescriptor, resolveSession: Resol return if (descriptor is FunctionDescriptor && descriptor.getValueParameters().isNotEmpty()) element.keepOldArgumentListOnTab() else element } -fun JetType.isSubtypeOf(expectedType: JetType) = !isError() && JetTypeChecker.INSTANCE.isSubtypeOf(this, expectedType) +fun JetType.isSubtypeOf(expectedType: JetType) = !isError() && JetTypeChecker.DEFAULT.isSubtypeOf(this, expectedType) fun T?.toList(): List = if (this != null) listOf(this) else listOf() fun T?.toSet(): Set = if (this != null) setOf(this) else setOf() diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/attributeCallReplacements/ReplaceContainsIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/attributeCallReplacements/ReplaceContainsIntention.kt index 00fd6a0167e..e44059121fe 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/attributeCallReplacements/ReplaceContainsIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/attributeCallReplacements/ReplaceContainsIntention.kt @@ -35,7 +35,7 @@ public open class ReplaceContainsIntention : AttributeCallReplacementIntention(" val ret = call.resolved.getResultingDescriptor().getReturnType() ?: return intentionFailed(editor, "undefined.returntype") - if (!JetTypeChecker.INSTANCE.isSubtypeOf(ret, KotlinBuiltIns.getInstance().getBooleanType())) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(ret, KotlinBuiltIns.getInstance().getBooleanType())) { return intentionFailed(editor, "contains.returns.boolean") } diff --git a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java index 08b53ebb4d2..c31950ace67 100644 --- a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java @@ -327,7 +327,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith if (argument.getArgumentExpression() != null) { JetType paramType = getActualParameterType(param); JetType exprType = bindingContext.get(BindingContext.EXPRESSION_TYPE, argument.getArgumentExpression()); - return exprType == null || JetTypeChecker.INSTANCE.isSubtypeOf(exprType, paramType); + return exprType == null || JetTypeChecker.DEFAULT.isSubtypeOf(exprType, paramType); } return false; diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java index dd64bfbeff5..6a57910e7ed 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java @@ -127,7 +127,7 @@ public class AddFunctionParametersFix extends ChangeFunctionSignatureFix { JetType argumentType = expression != null ? bindingContext.get(BindingContext.EXPRESSION_TYPE, expression) : null; JetType parameterType = parameters.get(i).getType(); - if (argumentType != null && !JetTypeChecker.INSTANCE.isSubtypeOf(argumentType, parameterType)) + if (argumentType != null && !JetTypeChecker.DEFAULT.isSubtypeOf(argumentType, parameterType)) changeSignatureData.getParameters().get(i).setTypeText(DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(argumentType)); } else { diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java index 816b583f2c0..aac9af29ccd 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionToSupertypeFix.java @@ -76,10 +76,10 @@ public class AddFunctionToSupertypeFix extends JetHintAction { if (o1.equals(o2)) { return 0; } - if (JetTypeChecker.INSTANCE.isSubtypeOf(o1, o2)) { + if (JetTypeChecker.DEFAULT.isSubtypeOf(o1, o2)) { return -1; } - if (JetTypeChecker.INSTANCE.isSubtypeOf(o2, o1)) { + if (JetTypeChecker.DEFAULT.isSubtypeOf(o2, o1)) { return 1; } return o1.toString().compareTo(o2.toString()); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java index 4a60dc9aefb..b8785740004 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java @@ -76,7 +76,7 @@ public class AddNameToArgumentFix extends JetIntentionAction { for (ValueParameterDescriptor parameter: callableDescriptor.getValueParameters()) { String name = parameter.getName().asString(); if (usedParameters.contains(name)) continue; - if (type == null || JetTypeChecker.INSTANCE.isSubtypeOf(type, parameter.getType())) { + if (type == null || JetTypeChecker.DEFAULT.isSubtypeOf(type, parameter.getType())) { names.add(name); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java index 4390f5eff4f..5315f2f9a8b 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/CastExpressionFix.java @@ -61,7 +61,7 @@ public class CastExpressionFix extends JetIntentionAction { if (!super.isAvailable(project, editor, file)) return false; BindingContext context = ResolvePackage.getBindingContext((JetFile) file); JetType expressionType = context.get(BindingContext.EXPRESSION_TYPE, element); - return expressionType != null && JetTypeChecker.INSTANCE.isSubtypeOf(type, expressionType); + return expressionType != null && JetTypeChecker.DEFAULT.isSubtypeOf(type, expressionType); } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java index d72d5ef61fa..e850ebac514 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralReturnTypeFix.java @@ -68,7 +68,7 @@ public class ChangeFunctionLiteralReturnTypeFix extends JetIntentionAction for (FunctionDescriptor overriddenFunction: descriptor.getOverriddenDescriptors()) { JetType overriddenFunctionType = overriddenFunction.getReturnType(); if (overriddenFunctionType == null) continue; - if (!JetTypeChecker.INSTANCE.isSubtypeOf(functionType, overriddenFunctionType)) { + if (!JetTypeChecker.DEFAULT.isSubtypeOf(functionType, overriddenFunctionType)) { overriddenMismatchingFunctions.add(overriddenFunction); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionSignatureFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionSignatureFix.java index f5094022b7d..2be9908055b 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionSignatureFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionSignatureFix.java @@ -132,7 +132,7 @@ public abstract class ChangeFunctionSignatureFix extends JetIntentionAction ErrorUtils.containsErrorType(expectedType) }) { return array() } - val theType = TypeUtils.intersect(JetTypeChecker.INSTANCE, expectedTypes) + val theType = TypeUtils.intersect(JetTypeChecker.DEFAULT, expectedTypes) if (theType != null) { return array(theType) } @@ -494,8 +494,8 @@ private class JetTypeSubstitution(public val forType: JetType, public val byType private fun JetType.substitute(substitution: JetTypeSubstitution, variance: Variance): JetType { if (when (variance) { Variance.INVARIANT -> this == substitution.forType - Variance.IN_VARIANCE -> JetTypeChecker.INSTANCE.isSubtypeOf(this, substitution.forType) - Variance.OUT_VARIANCE -> JetTypeChecker.INSTANCE.isSubtypeOf(substitution.forType, this) + Variance.IN_VARIANCE -> JetTypeChecker.DEFAULT.isSubtypeOf(this, substitution.forType) + Variance.OUT_VARIANCE -> JetTypeChecker.DEFAULT.isSubtypeOf(substitution.forType, this) }) { return substitution.byType } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java index b807f17be18..65e26224f91 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java @@ -90,10 +90,10 @@ public class QuickFixUtil { if (overriddenReturnType == null) { return null; } - if (matchingReturnType == null || JetTypeChecker.INSTANCE.isSubtypeOf(overriddenReturnType, matchingReturnType)) { + if (matchingReturnType == null || JetTypeChecker.DEFAULT.isSubtypeOf(overriddenReturnType, matchingReturnType)) { matchingReturnType = overriddenReturnType; } - else if (!JetTypeChecker.INSTANCE.isSubtypeOf(matchingReturnType, overriddenReturnType)) { + else if (!JetTypeChecker.DEFAULT.isSubtypeOf(matchingReturnType, overriddenReturnType)) { return null; } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameSuggester.java b/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameSuggester.java index 24674e39958..a7efdec3eaa 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameSuggester.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/JetNameSuggester.java @@ -98,7 +98,7 @@ public class JetNameSuggester { private static void addNamesForType(ArrayList result, JetType jetType, JetNameValidator validator) { KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); - JetTypeChecker typeChecker = JetTypeChecker.INSTANCE; + JetTypeChecker typeChecker = JetTypeChecker.DEFAULT; jetType = TypeUtils.makeNotNullable(jetType); // wipe out '?' if (ErrorUtils.containsErrorType(jetType)) return; if (typeChecker.equalTypes(builtIns.getBooleanType(), jetType)) { diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java index 2509d0e1c92..43af6fed9b4 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java @@ -440,7 +440,7 @@ public class JetRefactoringUtil { BindingContext bindingContext = AnalyzerFacadeWithCache.getContextForElement(expression); JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression); if (expressionType == null || !(expressionType instanceof PackageType) && - !JetTypeChecker.INSTANCE.equalTypes(KotlinBuiltIns. + !JetTypeChecker.DEFAULT.equalTypes(KotlinBuiltIns. getInstance().getUnitType(), expressionType)) { expressions.add(expression); } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java b/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java index 4050baea7c2..422ec0d83c3 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java @@ -31,11 +31,8 @@ import com.intellij.psi.PsiWhiteSpace; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.refactoring.HelpID; import com.intellij.refactoring.introduce.inplace.OccurrencesChooser; -import kotlin.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.analyzer.AnalyzerPackage; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -139,7 +136,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase { JetType typeNoExpectedType = AnalyzerPackage.computeTypeInfoInContext( expression, scope, bindingTrace, dataFlowInfo, TypeUtils.NO_EXPECTED_TYPE, resolveSession.getModuleDescriptor() ).getType(); - if (expressionType != null && typeNoExpectedType != null && !JetTypeChecker.INSTANCE.equalTypes(expressionType, + if (expressionType != null && typeNoExpectedType != null && !JetTypeChecker.DEFAULT.equalTypes(expressionType, typeNoExpectedType)) { noTypeInference = true; } @@ -149,7 +146,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase { return; } if (expressionType != null && - JetTypeChecker.INSTANCE.equalTypes(KotlinBuiltIns.getInstance().getUnitType(), expressionType)) { + JetTypeChecker.DEFAULT.equalTypes(KotlinBuiltIns.getInstance().getUnitType(), expressionType)) { showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.expression.has.unit.type")); return; }