From c719ae427a816ecb91eea17720c288dabf605fb8 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 17 Oct 2012 11:39:45 +0400 Subject: [PATCH] JetStandardClasses -> KotlinBuiltIns --- .../jetbrains/jet/codegen/CodegenUtil.java | 6 ++-- .../jet/codegen/ExpressionCodegen.java | 4 +-- .../codegen/ImplementationBodyCodegen.java | 4 +-- .../binding/CodegenAnnotatingVisitor.java | 6 ++-- .../jet/codegen/binding/CodegenBinding.java | 4 +-- .../codegen/intrinsics/IntrinsicMethods.java | 30 ++++++++++--------- .../jet/codegen/state/JetTypeMapper.java | 8 ++--- .../jet/cli/jvm/repl/ReplInterpreter.java | 10 +++---- .../resolve/java/JavaToKotlinClassMap.java | 4 +-- .../java/JavaToKotlinClassMapBuilder.java | 4 +-- .../java/JetTypeJetSignatureReader.java | 8 ++--- .../ElementAlternativeSignatureData.java | 4 +-- .../TypeTransformingVisitor.java | 12 ++++---- .../java/resolver/JavaSignatureResolver.java | 6 ++-- .../java/resolver/JavaSupertypesResolver.java | 8 ++--- .../jet/lang/DefaultModuleConfiguration.java | 6 ++-- .../jet/lang/cfg/JetControlFlowProcessor.java | 8 ++--- .../lang/cfg/JetFlowInformationProvider.java | 10 +++---- .../descriptors/FunctionDescriptorUtil.java | 12 ++++---- .../descriptors/PropertySetterDescriptor.java | 4 +-- .../lang/descriptors/ScriptDescriptor.java | 4 +-- .../TypeParameterDescriptorImpl.java | 14 ++++----- .../jetbrains/jet/lang/psi/JetPsiUtil.java | 4 +-- .../jet/lang/resolve/DescriptorResolver.java | 10 +++---- .../jet/lang/resolve/DescriptorUtils.java | 6 ++-- .../jet/lang/resolve/TopDownAnalyzer.java | 6 ++-- .../jet/lang/resolve/TypeResolver.java | 8 ++--- .../jet/lang/resolve/calls/CallResolver.java | 4 +-- .../calls/autocasts/DataFlowValue.java | 6 ++-- .../calls/autocasts/DataFlowValueFactory.java | 4 +-- .../calls/inference/ConstraintSystemImpl.java | 6 ++-- .../CompileTimeConstantResolver.java | 4 +-- .../jet/lang/resolve/constants/NullValue.java | 4 +-- .../lazy/LazyTypeParameterDescriptor.java | 8 ++--- .../scopes/receivers/ScriptReceiver.java | 4 +-- .../jet/lang/types/CommonSupertypes.java | 8 ++--- .../jetbrains/jet/lang/types/ErrorUtils.java | 4 +-- .../jet/lang/types/SubstitutionUtils.java | 4 +-- .../jet/lang/types/TypeSubstitutor.java | 4 +-- .../jetbrains/jet/lang/types/TypeUtils.java | 8 ++--- .../types/checker/TypeCheckingProcedure.java | 6 ++-- .../BasicExpressionTypingVisitor.java | 18 +++++------ .../ClosureExpressionsTypingVisitor.java | 20 ++++++------- .../ControlStructureTypingVisitor.java | 30 +++++++++---------- .../lang/types/expressions/DataFlowUtils.java | 8 ++--- .../expressions/ExpressionTypingServices.java | 14 ++++----- .../expressions/ExpressionTypingUtils.java | 4 +-- .../ExpressionTypingVisitorForStatements.java | 6 ++-- .../PatternMatchingTypingVisitor.java | 4 +-- .../jet/lang/types/lang/PrimitiveType.java | 7 +++-- .../jet/resolve/DescriptorRenderer.java | 26 ++++++++-------- .../jetbrains/jet/asJava/JetLightClass.java | 4 +-- .../jet/test/util/NamespaceComparator.java | 4 +-- .../jet/types/JetTypeCheckerTest.java | 18 +++++------ .../jetbrains/jet/plugin/JetPluginUtil.java | 6 ++-- .../jet/plugin/caches/JetShortNamesCache.java | 4 +-- .../codeInsight/GotoSuperActionHandler.java | 4 +-- .../OverrideImplementMethodsHandler.java | 4 +-- .../ReferenceToClassesShortening.java | 4 +-- .../completion/DescriptorLookupConverter.java | 4 +-- .../quickfix/MigrateTuplesInProjectFix.java | 4 +-- .../StandardLibraryReferenceResolver.java | 13 ++++---- .../StandardLibraryReferenceResolverTest.java | 4 +-- .../jet/j2k/visitors/TypeVisitor.java | 4 +-- .../k2js/analyze/JsConfiguration.java | 4 +-- .../utils/FunctionBodyTranslator.java | 4 +-- .../translate/utils/JsDescriptorUtils.java | 4 +-- 67 files changed, 256 insertions(+), 254 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java index c75d1ba12d5..11ac4f2fe84 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java @@ -37,7 +37,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.*; @@ -81,7 +81,7 @@ public class CodegenUtil { public static SimpleFunctionDescriptor createInvoke(FunctionDescriptor fd) { int arity = fd.getValueParameters().size(); SimpleFunctionDescriptorImpl invokeDescriptor = new SimpleFunctionDescriptorImpl( - fd.getExpectedThisObject().exists() ? JetStandardClasses.getReceiverFunction(arity) : JetStandardClasses.getFunction(arity), + fd.getExpectedThisObject().exists() ? KotlinBuiltIns.getInstance().getExtensionFunction(arity) : KotlinBuiltIns.getInstance().getFunction(arity), Collections.emptyList(), Name.identifier("invoke"), CallableMemberDescriptor.Kind.DECLARATION); @@ -196,7 +196,7 @@ public class CodegenUtil { return descriptor.getDefaultType(); } } - return JetStandardClasses.getAnyType(); + return KotlinBuiltIns.getInstance().getAnyType(); } public static T unwrapFakeOverride(T member) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 6682c3c4254..938a73056d6 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -54,7 +54,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.scopes.receivers.*; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.resolve.DescriptorRenderer; @@ -2474,7 +2474,7 @@ public class ExpressionCodegen extends JetVisitor implem else { JetType type = ((FunctionDescriptor) op).getReturnType(); assert type != null; - final boolean keepReturnValue = !type.equals(JetStandardClasses.getUnitType()); + final boolean keepReturnValue = !type.equals(KotlinBuiltIns.getInstance().getUnitType()); callAugAssignMethod(expression, (CallableMethod) callable, lhsType, keepReturnValue); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 3b0e7adbbc0..cb2623df65e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -52,7 +52,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; import org.jetbrains.jet.lang.resolve.java.kt.DescriptorKindUtils; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lexer.JetTokens; @@ -441,7 +441,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { private void generateDataClassEqualsIfNeeded(List properties) { ClassDescriptor booleanClass = JetStandardLibrary.getInstance().getBoolean(); - ClassDescriptor anyClass = JetStandardClasses.getAny(); + ClassDescriptor anyClass = KotlinBuiltIns.getInstance().getAny(); FunctionDescriptor equalsFunction = getDeclaredFunctionByRawSignature(descriptor, Name.identifier("equals"), booleanClass, anyClass); if (equalsFunction == null) { generateDataClassEqualsMethod(properties); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java index 977822ddbfc..34fe75e25af 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java @@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.Collections; import java.util.HashMap; @@ -65,8 +65,8 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid { false, Collections.emptyList(), Collections.singleton((funDescriptor.getReceiverParameter().exists() - ? JetStandardClasses.getReceiverFunction(arity) - : JetStandardClasses.getFunction(arity)).getDefaultType()), JetScope.EMPTY, + ? KotlinBuiltIns.getInstance().getExtensionFunction(arity) + : KotlinBuiltIns.getInstance().getFunction(arity)).getDefaultType()), JetScope.EMPTY, Collections.emptySet(), null); assert PsiCodegenPredictor.checkPredictedClassNameForFun(bindingContext, funDescriptor, classDescriptor); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java index d040c981f77..d4cdfbb57ae 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java @@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.util.slicedmap.Slices; import org.jetbrains.jet.util.slicedmap.WritableSlice; @@ -125,7 +125,7 @@ public class CodegenBinding { classDescriptor.initialize( false, Collections.emptyList(), - Collections.singletonList(JetStandardClasses.getAnyType()), + Collections.singletonList(KotlinBuiltIns.getInstance().getAnyType()), JetScope.EMPTY, Collections.emptySet(), null); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java index 4eea52b6ca4..d3b8a5a7d4f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java @@ -23,10 +23,11 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.expressions.OperatorConventions; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.PrimitiveType; import javax.annotation.PostConstruct; @@ -119,16 +120,17 @@ public class IntrinsicMethods { declareIntrinsicFunction(Name.identifier("CharSequence"), Name.identifier("get"), 1, new StringGetChar()); declareIntrinsicFunction(Name.identifier("String"), Name.identifier("get"), 1, new StringGetChar()); - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME, Name.identifier("name"), 0, new EnumName()); - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME, Name.identifier("ordinal"), 0, new EnumOrdinal()); + FqName builtInsPackageFqName = KotlinBuiltIns.getInstance().getBuiltInsPackageFqName(); + intrinsicsMap.registerIntrinsic(builtInsPackageFqName, Name.identifier("name"), 0, new EnumName()); + intrinsicsMap.registerIntrinsic(builtInsPackageFqName, Name.identifier("ordinal"), 0, new EnumOrdinal()); - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME, Name.identifier("toString"), 0, TO_STRING); - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME, Name.identifier("equals"), 1, EQUALS); - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME, Name.identifier("identityEquals"), 1, IDENTITY_EQUALS); - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME, Name.identifier("plus"), 1, STRING_PLUS); - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME, Name.identifier("arrayOfNulls"), 1, new NewArray()); - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME, Name.identifier("synchronized"), 2, new StupidSync()); - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME, Name.identifier("iterator"), 0, new IteratorIterator()); + intrinsicsMap.registerIntrinsic(builtInsPackageFqName, Name.identifier("toString"), 0, TO_STRING); + intrinsicsMap.registerIntrinsic(builtInsPackageFqName, Name.identifier("equals"), 1, EQUALS); + intrinsicsMap.registerIntrinsic(builtInsPackageFqName, Name.identifier("identityEquals"), 1, IDENTITY_EQUALS); + intrinsicsMap.registerIntrinsic(builtInsPackageFqName, Name.identifier("plus"), 1, STRING_PLUS); + intrinsicsMap.registerIntrinsic(builtInsPackageFqName, Name.identifier("arrayOfNulls"), 1, new NewArray()); + intrinsicsMap.registerIntrinsic(builtInsPackageFqName, Name.identifier("synchronized"), 2, new StupidSync()); + intrinsicsMap.registerIntrinsic(builtInsPackageFqName, Name.identifier("iterator"), 0, new IteratorIterator()); declareIntrinsicFunction(Name.identifier("ByteIterator"), Name.identifier("next"), 0, ITERATOR_NEXT); @@ -148,7 +150,7 @@ public class IntrinsicMethods { declareIntrinsicProperty(Name.identifier("CharSequence"), Name.identifier("length"), new StringLength()); declareIntrinsicProperty(Name.identifier("String"), Name.identifier("length"), new StringLength()); - Name tuple0Name = JetStandardClasses.getTuple(0).getName(); + Name tuple0Name = KotlinBuiltIns.getInstance().getTuple(0).getName(); intrinsicsMap.registerIntrinsic( getClassObjectFqName(tuple0Name), Name.identifier("VALUE"), -1, new UnitValue()); @@ -164,7 +166,7 @@ public class IntrinsicMethods { @NotNull private static FqNameUnsafe getClassObjectFqName(@NotNull Name builtinClassName) { - return JetStandardClasses.STANDARD_CLASSES_FQNAME.child(builtinClassName).toUnsafe().child(getClassObjectName(builtinClassName)); + return KotlinBuiltIns.getInstance().getBuiltInsPackageFqName().child(builtinClassName).toUnsafe().child(getClassObjectName(builtinClassName)); } private void declareArrayMethods() { @@ -201,11 +203,11 @@ public class IntrinsicMethods { } private void declareIntrinsicProperty(Name className, Name methodName, IntrinsicMethod implementation) { - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME.child(className), methodName, -1, implementation); + intrinsicsMap.registerIntrinsic(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName().child(className), methodName, -1, implementation); } private void declareIntrinsicFunction(Name className, Name functionName, int arity, IntrinsicMethod implementation) { - intrinsicsMap.registerIntrinsic(JetStandardClasses.STANDARD_CLASSES_FQNAME.child(className), functionName, arity, implementation); + intrinsicsMap.registerIntrinsic(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName().child(className), functionName, arity, implementation); } @Nullable diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java index 61489afacaa..49128fe10ba 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java @@ -37,7 +37,7 @@ import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.ArrayList; @@ -173,19 +173,19 @@ public class JetTypeMapper extends BindingTraceAware { @NotNull private Type mapReturnType(@NotNull final JetType jetType, @Nullable BothSignatureWriter signatureVisitor) { - if (jetType.equals(JetStandardClasses.getUnitType())) { + if (jetType.equals(KotlinBuiltIns.getInstance().getUnitType())) { if (signatureVisitor != null) { signatureVisitor.writeAsmType(Type.VOID_TYPE, false); } return Type.VOID_TYPE; } - else if (jetType.equals(JetStandardClasses.getNothingType())) { + else if (jetType.equals(KotlinBuiltIns.getInstance().getNothingType())) { if (signatureVisitor != null) { signatureVisitor.writeNothing(false); } return Type.VOID_TYPE; } - if (jetType.equals(JetStandardClasses.getNullableNothingType())) { + if (jetType.equals(KotlinBuiltIns.getInstance().getNullableNothingType())) { if (signatureVisitor != null) { signatureVisitor.writeNothing(true); } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index fcfccf638a4..a006533dada 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java @@ -35,7 +35,8 @@ import org.jetbrains.jet.cli.common.messages.MessageCollector; import org.jetbrains.jet.cli.common.messages.MessageCollectorToString; import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.codegen.*; +import org.jetbrains.jet.codegen.ClassBuilderFactories; +import org.jetbrains.jet.codegen.CompilationErrorHandler; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; @@ -52,10 +53,9 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetLanguage; import org.jetbrains.jet.utils.ExceptionUtils; -import org.jetbrains.jet.utils.Progress; import java.io.File; import java.io.PrintWriter; @@ -261,7 +261,7 @@ public class ReplInterpreter { earlierLines.add(new EarlierLine(line, scriptDescriptor, scriptClass, scriptInstance, scriptClassName)); - return LineResult.successful(rv, scriptDescriptor.getReturnType().equals(JetStandardClasses.getUnitType())); + return LineResult.successful(rv, scriptDescriptor.getReturnType().equals(KotlinBuiltIns.getInstance().getUnitType())); } catch (Throwable e) { PrintWriter writer = new PrintWriter(System.err); classLoader.dumpClasses(writer); @@ -282,7 +282,7 @@ public class ReplInterpreter { // map "jet" namespace into JetStandardLibrary/Classes // @see DefaultModuleConfiguraiton#extendNamespaceScope - injector.getNamespaceFactory().createNamespaceDescriptorPathIfNeeded(JetStandardClasses.STANDARD_CLASSES_FQNAME); + injector.getNamespaceFactory().createNamespaceDescriptorPathIfNeeded(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName()); // Import a scope that contains all top-level namespaces that come from dependencies // This makes the namespaces visible at all, does not import themselves diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java index 71837fc304c..edb7a89a6e6 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java @@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lang.types.lang.PrimitiveType; @@ -70,7 +70,7 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements primitiveTypesMap.put(jvmPrimitiveType.getWrapper().getFqName().getFqName(), JetStandardLibrary.getInstance().getNullablePrimitiveJetType( primitiveType)); } - primitiveTypesMap.put("void", JetStandardClasses.getUnitType()); + primitiveTypesMap.put("void", KotlinBuiltIns.getInstance().getUnitType()); } @Nullable diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMapBuilder.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMapBuilder.java index 598c45dc438..7bdcfad960b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMapBuilder.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMapBuilder.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.lang.annotation.Annotation; @@ -32,7 +32,7 @@ public abstract class JavaToKotlinClassMapBuilder { /*package*/ void init() { JetStandardLibrary standardLibrary = JetStandardLibrary.getInstance(); - register(Object.class, JetStandardClasses.getAny()); + register(Object.class, KotlinBuiltIns.getInstance().getAny()); register(String.class, standardLibrary.getString()); register(CharSequence.class, standardLibrary.getCharSequence()); register(Throwable.class, standardLibrary.getThrowable()); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java index 8dadf73f576..4be70294b10 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java @@ -23,7 +23,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; import org.jetbrains.jet.rt.signature.JetSignatureVariance; @@ -61,7 +61,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd } } if (descriptor == 'V') { - return JetStandardClasses.getUnitType(); + return KotlinBuiltIns.getInstance().getUnitType(); } } else { @@ -119,12 +119,12 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd // TODO: this is the worst code in Kotlin project Matcher functionMatcher = Pattern.compile("jet\\.Function(\\d+)").matcher(ourName.getFqName()); if (functionMatcher.matches()) { - return JetStandardClasses.getFunction(Integer.parseInt(functionMatcher.group(1))); + return KotlinBuiltIns.getInstance().getFunction(Integer.parseInt(functionMatcher.group(1))); } Matcher patternMatcher = Pattern.compile("jet\\.Tuple(\\d+)").matcher(ourName.getFqName()); if (patternMatcher.matches()) { - return JetStandardClasses.getTuple(Integer.parseInt(patternMatcher.group(1))); + return KotlinBuiltIns.getInstance().getTuple(Integer.parseInt(patternMatcher.group(1))); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/ElementAlternativeSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/ElementAlternativeSignatureData.java index bf64e3719b7..6002da94dfa 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/ElementAlternativeSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/ElementAlternativeSignatureData.java @@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.psi.JetTypeElement; import org.jetbrains.jet.lang.psi.JetTypeReference; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.resolve.DescriptorRenderer; import java.util.List; @@ -89,7 +89,7 @@ public abstract class ElementAlternativeSignatureData { @Nullable JetTypeReference altReturnTypeReference, @NotNull Map originalToAltTypeParameters) { if (altReturnTypeReference == null) { - if (JetStandardClasses.isUnit(originalType)) { + if (KotlinBuiltIns.getInstance().isUnit(originalType)) { return originalType; } else { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java index e46cb928d94..9dceb8119c8 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/TypeTransformingVisitor.java @@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.KotlinToJavaTypesMap; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.resolve.DescriptorRenderer; import java.util.*; @@ -70,13 +70,13 @@ class TypeTransformingVisitor extends JetVisitor { @Override public JetType visitFunctionType(JetFunctionType type, Void data) { return visitCommonType(type.getReceiverTypeRef() == null - ? JetStandardClasses.getFunction(type.getParameters().size()) - : JetStandardClasses.getReceiverFunction(type.getParameters().size()), type); + ? KotlinBuiltIns.getInstance().getFunction(type.getParameters().size()) + : KotlinBuiltIns.getInstance().getExtensionFunction(type.getParameters().size()), type); } @Override public JetType visitTupleType(JetTupleType type, Void data) { - return visitCommonType(JetStandardClasses.getTuple(type.getComponentTypeRefs().size()), type); + return visitCommonType(KotlinBuiltIns.getInstance().getTuple(type.getComponentTypeRefs().size()), type); } @Override @@ -87,8 +87,8 @@ class TypeTransformingVisitor extends JetVisitor { String shortName = type.getReferenceExpression().getReferencedName(); String longName = (qualifier == null ? "" : qualifier.getText() + ".") + shortName; - if (JetStandardClasses.UNIT_ALIAS.getName().equals(longName)) { - return visitCommonType(JetStandardClasses.getTuple(0), type); + if (KotlinBuiltIns.getInstance().UNIT_ALIAS.getName().equals(longName)) { + return visitCommonType(KotlinBuiltIns.getInstance().getTuple(0), type); } return visitCommonType(longName, type); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java index 611d043e048..098fe573eaf 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java @@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.Variance; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.rt.signature.JetSignatureAdapter; import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; @@ -278,7 +278,7 @@ public final class JavaSignatureResolver { final List upperBoundsForKotlin = typeParameter.upperBoundsForKotlin; assert upperBoundsForKotlin != null; if (upperBoundsForKotlin.size() == 0){ - typeParameterDescriptor.addUpperBound(JetStandardClasses.getNullableAnyType()); + typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType()); } else { for (JetType upperBound : upperBoundsForKotlin) { @@ -291,7 +291,7 @@ public final class JavaSignatureResolver { else { PsiClassType[] referencedTypes = typeParameter.psiTypeParameter.getExtendsList().getReferencedTypes(); if (referencedTypes.length == 0){ - typeParameterDescriptor.addUpperBound(JetStandardClasses.getNullableAnyType()); + typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType()); } else if (referencedTypes.length == 1) { typeParameterDescriptor.addUpperBound(semanticServices.getTypeTransformer().transformToType(referencedTypes[0], JavaTypeTransformer.TypeUsage.UPPER_BOUND, typeVariableByPsiResolver)); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypesResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypesResolver.java index 6de47e166bd..9728fbcbef7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypesResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypesResolver.java @@ -32,7 +32,7 @@ import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.rt.signature.JetSignatureAdapter; import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; @@ -123,7 +123,7 @@ public final class JavaSupertypesResolver { typeVariableResolver) { @Override protected void done(@NotNull JetType jetType) { - if (!jetType.equals(JetStandardClasses.getAnyType())) { + if (!jetType.equals(KotlinBuiltIns.getInstance().getAnyType())) { result.add(jetType); } } @@ -147,7 +147,7 @@ public final class JavaSupertypesResolver { || DescriptorResolverUtils.OBJECT_FQ_NAME.equalsTo(psiClass.getQualifiedName()) // TODO: annotations || classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) { - result.add(JetStandardClasses.getAnyType()); + result.add(KotlinBuiltIns.getInstance().getAnyType()); } else { ClassDescriptor object = resolveJavaLangObject(); @@ -156,7 +156,7 @@ public final class JavaSupertypesResolver { } else { //TODO: hack here - result.add(JetStandardClasses.getAnyType()); + result.add(KotlinBuiltIns.getInstance().getAnyType()); // throw new IllegalStateException("Could not resolve java.lang.Object"); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java b/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java index 1dea916ef01..f0ea9cf73bc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java @@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.Collection; @@ -58,13 +58,13 @@ public class DefaultModuleConfiguration implements ModuleConfiguration { @Override public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { - if (DescriptorUtils.getFQName(namespaceDescriptor).equalsTo(JetStandardClasses.STANDARD_CLASSES_FQNAME)) { + if (DescriptorUtils.getFQName(namespaceDescriptor).equalsTo(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName())) { switch (builtinsScopeExtensionMode) { case ALL: namespaceMemberScope.importScope(JetStandardLibrary.getInstance().getLibraryScope()); break; case ONLY_STANDARD_CLASSES: - namespaceMemberScope.importScope(JetStandardClasses.STANDARD_CLASSES); + namespaceMemberScope.importScope(KotlinBuiltIns.getInstance().getBuiltInsScope()); break; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java index 804b834b864..c4989580379 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java @@ -34,7 +34,7 @@ import org.jetbrains.jet.lang.resolve.constants.BooleanValue; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstantResolver; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.expressions.OperatorConventions; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lexer.JetTokens; @@ -170,7 +170,7 @@ public class JetControlFlowProcessor { builder.read(expression); if (trace.get(BindingContext.PROCESSED, expression)) { JetType type = trace.getBindingContext().get(BindingContext.EXPRESSION_TYPE, expression); - if (type != null && JetStandardClasses.isNothing(type)) { + if (type != null && KotlinBuiltIns.getInstance().isNothing(type)) { builder.jumpToError(expression); } } @@ -627,7 +627,7 @@ public class JetControlFlowProcessor { builder.read(expression); if (trace.get(BindingContext.PROCESSED, expression)) { JetType type = trace.getBindingContext().get(BindingContext.EXPRESSION_TYPE, expression); - if (type != null && JetStandardClasses.isNothing(type)) { + if (type != null && KotlinBuiltIns.getInstance().isNothing(type)) { builder.jumpToError(expression); } } @@ -669,7 +669,7 @@ public class JetControlFlowProcessor { builder.read(expression); if (trace.get(BindingContext.PROCESSED, expression)) { JetType type = trace.getBindingContext().get(BindingContext.EXPRESSION_TYPE, expression); - if (type != null && JetStandardClasses.isNothing(type)) { + if (type != null && KotlinBuiltIns.getInstance().isNothing(type)) { builder.jumpToError(expression); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java index 7a55aaa41e3..e2179b9bffb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java @@ -35,7 +35,7 @@ import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.plugin.JetMainDetector; @@ -135,7 +135,7 @@ public class JetFlowInformationProvider { returnedExpressions.remove(function); // This will be the only "expression" if the body is empty - if (expectedReturnType != NO_EXPECTED_TYPE && !JetStandardClasses.isUnit(expectedReturnType) && returnedExpressions.isEmpty() && !nothingReturned) { + if (expectedReturnType != NO_EXPECTED_TYPE && !KotlinBuiltIns.getInstance().isUnit(expectedReturnType) && returnedExpressions.isEmpty() && !nothingReturned) { trace.report(RETURN_TYPE_MISMATCH.on(bodyExpression, expectedReturnType)); } final boolean blockBody = function.hasBlockBody(); @@ -157,7 +157,7 @@ public class JetFlowInformationProvider { @Override public void visitExpression(JetExpression expression) { - if (blockBody && expectedReturnType != NO_EXPECTED_TYPE && !JetStandardClasses.isUnit(expectedReturnType) && !rootUnreachableElements.contains(expression)) { + if (blockBody && expectedReturnType != NO_EXPECTED_TYPE && !KotlinBuiltIns.getInstance().isUnit(expectedReturnType) && !rootUnreachableElements.contains(expression)) { noReturnError[0] = true; } } @@ -290,7 +290,7 @@ public class JetFlowInformationProvider { if (operationReference != null) { DeclarationDescriptor descriptor = trace.get(BindingContext.REFERENCE_TARGET, operationReference); if (descriptor instanceof FunctionDescriptor) { - if (JetStandardClasses.isUnit(((FunctionDescriptor) descriptor).getReturnType())) { + if (KotlinBuiltIns.getInstance().isUnit(((FunctionDescriptor) descriptor).getReturnType())) { hasReassignMethodReturningUnit = true; } } @@ -298,7 +298,7 @@ public class JetFlowInformationProvider { Collection descriptors = trace.get(BindingContext.AMBIGUOUS_REFERENCE_TARGET, operationReference); if (descriptors != null) { for (DeclarationDescriptor referenceDescriptor : descriptors) { - if (JetStandardClasses.isUnit(((FunctionDescriptor) referenceDescriptor).getReturnType())) { + if (KotlinBuiltIns.getInstance().isUnit(((FunctionDescriptor) referenceDescriptor).getReturnType())) { hasReassignMethodReturningUnit = true; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java index 4caafc8ad3d..f170557cd9f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java @@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.*; @@ -123,12 +123,12 @@ public class FunctionDescriptorUtil { public static void initializeFromFunctionType(@NotNull FunctionDescriptorImpl functionDescriptor, @NotNull JetType functionType, @NotNull ReceiverDescriptor expectedThisObject, @NotNull Modality modality, @NotNull Visibility visibility) { - assert JetStandardClasses.isFunctionType(functionType); - functionDescriptor.initialize(JetStandardClasses.getReceiverType(functionType), + assert KotlinBuiltIns.getInstance().isFunctionType(functionType); + functionDescriptor.initialize(KotlinBuiltIns.getInstance().getReceiverType(functionType), expectedThisObject, Collections.emptyList(), - JetStandardClasses.getValueParameters(functionDescriptor, functionType), - JetStandardClasses.getReturnTypeFromFunctionType(functionType), + KotlinBuiltIns.getInstance().getValueParameters(functionDescriptor, functionType), + KotlinBuiltIns.getInstance().getReturnTypeFromFunctionType(functionType), modality, visibility); } @@ -138,7 +138,7 @@ public class FunctionDescriptorUtil { } public static FunctionDescriptor getInvokeFunction(@NotNull JetType functionType) { - assert JetStandardClasses.isFunctionType(functionType); + assert KotlinBuiltIns.getInstance().isFunctionType(functionType); ClassifierDescriptor classDescriptorForFunction = functionType.getConstructor().getDeclarationDescriptor(); assert classDescriptorForFunction instanceof ClassDescriptor; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java index fad4e04eace..82f0b841212 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java @@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.Collections; import java.util.List; @@ -88,7 +88,7 @@ public class PropertySetterDescriptor extends PropertyAccessorDescriptor { @NotNull @Override public JetType getReturnType() { - return JetStandardClasses.getUnitType(); + return KotlinBuiltIns.getInstance().getUnitType(); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java index 0689aa0ee15..025a3200001 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ScriptDescriptor.java @@ -34,7 +34,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.resolve.scopes.receivers.ScriptReceiver; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeSubstitutor; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.Collections; import java.util.HashSet; @@ -76,7 +76,7 @@ public class ScriptDescriptor extends DeclarationDescriptorNonRootImpl { classDescriptor.initialize( false, Collections.emptyList(), - Collections.singletonList(JetStandardClasses.getAnyType()), + Collections.singletonList(KotlinBuiltIns.getInstance().getAnyType()), classScope, new HashSet(), null); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptorImpl.java index ba84669b19b..2430cf6af0b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptorImpl.java @@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.resolve.DescriptorRenderer; import org.jetbrains.jet.util.lazy.LazyValue; @@ -44,7 +44,7 @@ public class TypeParameterDescriptorImpl extends DeclarationDescriptorNonRootImp @NotNull Name name, int index) { TypeParameterDescriptorImpl typeParameterDescriptor = createForFurtherModification(containingDeclaration, annotations, reified, variance, name, index); - typeParameterDescriptor.addUpperBound(JetStandardClasses.getDefaultBound()); + typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getDefaultBound()); typeParameterDescriptor.setInitialized(); return typeParameterDescriptor; } @@ -142,7 +142,7 @@ public class TypeParameterDescriptorImpl extends DeclarationDescriptorNonRootImp checkUninitialized(); if (upperBounds.isEmpty()) { - doAddUpperBound(JetStandardClasses.getDefaultBound()); + doAddUpperBound(KotlinBuiltIns.getInstance().getDefaultBound()); } } @@ -162,7 +162,7 @@ public class TypeParameterDescriptorImpl extends DeclarationDescriptorNonRootImp assert upperBounds.size() > 0 : "Upper bound list is empty in " + getName(); upperBoundsAsType = TypeUtils.intersect(JetTypeChecker.INSTANCE, upperBounds); if (upperBoundsAsType == null) { - upperBoundsAsType = JetStandardClasses.getNothingType(); + upperBoundsAsType = KotlinBuiltIns.getInstance().getNothingType(); } } return upperBoundsAsType; @@ -172,14 +172,14 @@ public class TypeParameterDescriptorImpl extends DeclarationDescriptorNonRootImp @NotNull public Set getLowerBounds() { //checkInitialized(); - return Collections.singleton(JetStandardClasses.getNothingType()); + return Collections.singleton(KotlinBuiltIns.getInstance().getNothingType()); } @Override @NotNull public JetType getLowerBoundsAsType() { checkInitialized(); - return JetStandardClasses.getNothingType(); + return KotlinBuiltIns.getInstance().getNothingType(); } @@ -240,7 +240,7 @@ public class TypeParameterDescriptorImpl extends DeclarationDescriptorNonRootImp if (classObjectBoundsAsType == null) { classObjectBoundsAsType = TypeUtils.intersect(JetTypeChecker.INSTANCE, classObjectUpperBounds); if (classObjectBoundsAsType == null) { - classObjectBoundsAsType = JetStandardClasses.getNothingType(); + classObjectBoundsAsType = KotlinBuiltIns.getInstance().getNothingType(); } } return classObjectBoundsAsType; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index 9d450eb28f1..d1a67912f5f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -29,7 +29,7 @@ import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.expressions.OperatorConventions; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetToken; import org.jetbrains.jet.lexer.JetTokens; @@ -306,7 +306,7 @@ public class JetPsiUtil { return false; } - return JetStandardClasses.UNIT_ALIAS.getName().equals(typeReference.getText()); + return KotlinBuiltIns.getInstance().UNIT_ALIAS.getName().equals(typeReference.getText()); } public static boolean isSafeCall(@NotNull Call call) { 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 ff1147696d2..d79723714bf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -37,7 +37,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; 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.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.util.lazy.LazyValue; @@ -183,7 +183,7 @@ public class DescriptorResolver { else if (jetClass instanceof JetClass && ((JetClass) jetClass).isAnnotation()) { return JetStandardLibrary.getInstance().getAnnotationType(); } - return JetStandardClasses.getAnyType(); + return KotlinBuiltIns.getInstance().getAnyType(); } public Collection resolveDelegationSpecifiers( @@ -267,7 +267,7 @@ public class DescriptorResolver { returnType = typeResolver.resolveType(innerScope, returnTypeRef, trace, true); } else if (function.hasBlockBody()) { - returnType = JetStandardClasses.getUnitType(); + returnType = KotlinBuiltIns.getInstance().getUnitType(); } else { final JetExpression bodyExpression = function.getBodyExpression(); @@ -574,7 +574,7 @@ public class DescriptorResolver { parameter.setInitialized(); - if (JetStandardClasses.isNothing(parameter.getUpperBoundsAsType())) { + if (KotlinBuiltIns.getInstance().isNothing(parameter.getUpperBoundsAsType())) { PsiElement nameIdentifier = typeParameters.get(parameter.getIndex()).getNameIdentifier(); if (nameIdentifier != null) { trace.report(CONFLICTING_UPPER_BOUNDS.on(nameIdentifier, parameter)); @@ -582,7 +582,7 @@ public class DescriptorResolver { } JetType classObjectType = parameter.getClassObjectType(); - if (classObjectType != null && JetStandardClasses.isNothing(classObjectType)) { + if (classObjectType != null && KotlinBuiltIns.getInstance().isNothing(classObjectType)) { PsiElement nameIdentifier = typeParameters.get(parameter.getIndex()).getNameIdentifier(); if (nameIdentifier != null) { trace.report(CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS.on(nameIdentifier, parameter)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index 990ab991d7d..637dcc6752e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -32,7 +32,7 @@ import org.jetbrains.jet.lang.types.DescriptorSubstitutor; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.*; @@ -272,7 +272,7 @@ public class DescriptorUtils { } public static boolean isNotAny(@NotNull DeclarationDescriptor superClassDescriptor) { - return !superClassDescriptor.equals(JetStandardClasses.getAny()); + return !superClassDescriptor.equals(KotlinBuiltIns.getInstance().getAny()); } public static boolean inStaticContext(@NotNull DeclarationDescriptor descriptor) { @@ -293,7 +293,7 @@ public class DescriptorUtils { public static boolean isIteratorWithoutRemoveImpl(@NotNull ClassDescriptor classDescriptor) { ClassDescriptor iteratorOfT = JetStandardLibrary.getInstance().getIterator(); - JetType iteratorOfAny = TypeUtils.substituteParameters(iteratorOfT, Collections.singletonList(JetStandardClasses.getAnyType())); + JetType iteratorOfAny = TypeUtils.substituteParameters(iteratorOfT, Collections.singletonList(KotlinBuiltIns.getInstance().getAnyType())); boolean isIterator = JetTypeChecker.INSTANCE.isSubtypeOf(classDescriptor.getDefaultType(), iteratorOfAny); boolean hasRemove = hasMethod(classDescriptor, Name.identifier("remove")); return isIterator && !hasRemove; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 6fb20e791bf..30b36f3ea63 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -32,7 +32,7 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import javax.inject.Inject; import java.util.*; @@ -163,7 +163,7 @@ public class TopDownAnalyzer { Predicates.alwaysFalse(), true, false, Collections.emptyList()); InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic( project, topDownAnalysisParameters, new ObservableBindingTrace(trace), - JetStandardClasses.FAKE_STANDARD_CLASSES_MODULE, ModuleConfiguration.EMPTY); + KotlinBuiltIns.getInstance().getBuiltInsModule(), ModuleConfiguration.EMPTY); injector.getTopDownAnalyzer().doProcessStandardLibraryNamespace(outerScope, standardLibraryNamespace, files); } @@ -246,7 +246,7 @@ public class TopDownAnalyzer { // map "jet" namespace into JetStandardLibrary/Classes // @see DefaultModuleConfiguraiton#extendNamespaceScope - namespaceFactory.createNamespaceDescriptorPathIfNeeded(JetStandardClasses.STANDARD_CLASSES_FQNAME); + namespaceFactory.createNamespaceDescriptorPathIfNeeded(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName()); // Import a scope that contains all top-level namespaces that come from dependencies // This makes the namespaces visible at all, does not import themselves diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java index 023cd1edceb..9a4d670cc25 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -28,7 +28,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter; import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.util.lazy.LazyValue; import javax.inject.Inject; @@ -188,7 +188,7 @@ public class TypeResolver { } // TODO labels - result[0] = JetStandardClasses.getTupleType(resolveTypes(scope, type.getComponentTypeRefs(), trace, checkBounds)); + result[0] = KotlinBuiltIns.getInstance().getTupleType(resolveTypes(scope, type.getComponentTypeRefs(), trace, checkBounds)); } @Override @@ -207,9 +207,9 @@ public class TypeResolver { returnType = resolveType(scope, returnTypeRef, trace, checkBounds); } else { - returnType = JetStandardClasses.getUnitType(); + returnType = KotlinBuiltIns.getInstance().getUnitType(); } - result[0] = JetStandardClasses.getFunctionType(annotations, receiverType, parameterTypes, returnType); + result[0] = KotlinBuiltIns.getInstance().getFunctionType(annotations, receiverType, parameterTypes, returnType); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 97100e42a62..061e259f6b6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -40,7 +40,7 @@ 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.expressions.ExpressionTypingUtils; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.util.slicedmap.WritableSlice; @@ -235,7 +235,7 @@ public class CallResolver { // Here we handle the case where the callee expression must be something of type function, e.g. (foo.bar())(1, 2) JetType calleeType = expressionTypingServices.safeGetType(context.scope, calleeExpression, NO_EXPECTED_TYPE, context.dataFlowInfo, context.trace); // We are actually expecting a function, but there seems to be no easy way of expressing this - if (!JetStandardClasses.isFunctionType(calleeType)) { + if (!KotlinBuiltIns.getInstance().isFunctionType(calleeType)) { // checkTypesWithNoCallee(trace, scope, call); if (!ErrorUtils.isErrorType(calleeType)) { context.trace.report(CALLEE_NOT_A_FUNCTION.on(calleeExpression, calleeType)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValue.java index fd33e672e3b..0b7a84552f3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValue.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValue.java @@ -17,7 +17,7 @@ package org.jetbrains.jet.lang.resolve.calls.autocasts; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.JetType; /** @@ -25,8 +25,8 @@ import org.jetbrains.jet.lang.types.JetType; */ public class DataFlowValue { - public static final DataFlowValue NULL = new DataFlowValue(new Object(), JetStandardClasses.getNullableNothingType(), false, Nullability.NULL); - public static final DataFlowValue NULLABLE = new DataFlowValue(new Object(), JetStandardClasses.getNullableAnyType(), false, Nullability.UNKNOWN); + public static final DataFlowValue NULL = new DataFlowValue(new Object(), KotlinBuiltIns.getInstance().getNullableNothingType(), false, Nullability.NULL); + public static final DataFlowValue NULLABLE = new DataFlowValue(new Object(), KotlinBuiltIns.getInstance().getNullableAnyType(), false, Nullability.UNKNOWN); private final boolean stableIdentifier; private final JetType type; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java index f2a80165b91..0ad46eca9b7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java @@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.resolve.JetModuleUtil; import org.jetbrains.jet.lang.resolve.scopes.receivers.ThisReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET; @@ -44,7 +44,7 @@ public class DataFlowValueFactory { JetConstantExpression constantExpression = (JetConstantExpression) expression; if (constantExpression.getNode().getElementType() == JetNodeTypes.NULL) return DataFlowValue.NULL; } - if (TypeUtils.equalTypes(type, JetStandardClasses.getNullableNothingType())) return DataFlowValue.NULL; // 'null' is the only inhabitant of 'Nothing?' + if (TypeUtils.equalTypes(type, KotlinBuiltIns.getInstance().getNullableNothingType())) return DataFlowValue.NULL; // 'null' is the only inhabitant of 'Nothing?' Pair result = getIdForStableIdentifier(expression, bindingContext, false); return new DataFlowValue(result.first == null ? expression : result.first, type, result.second, getImmanentNullability(type)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintSystemImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintSystemImpl.java index 7bc898a29b1..566ee6628ba 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintSystemImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/inference/ConstraintSystemImpl.java @@ -27,7 +27,7 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.TypeCheckingProcedure; import org.jetbrains.jet.lang.resolve.calls.inference.TypeConstraintsImpl.ConstraintKind; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.*; @@ -196,7 +196,7 @@ public class ConstraintSystemImpl implements ConstraintSystem { } switch (constraintKind) { case SUPER_TYPE: { - if (JetStandardClasses.isNothingOrNullableNothing(constrainingType)) break; + if (KotlinBuiltIns.getInstance().isNothingOrNullableNothing(constrainingType)) break; JetType correspondingSupertype = TypeCheckingProcedure.findCorrespondingSupertype(constrainingType, subjectType); if (correspondingSupertype != null) { constrainingType = correspondingSupertype; @@ -204,7 +204,7 @@ public class ConstraintSystemImpl implements ConstraintSystem { break; } case SUB_TYPE: { - if (JetStandardClasses.isNothingOrNullableNothing(subjectType)) break; + if (KotlinBuiltIns.getInstance().isNothingOrNullableNothing(subjectType)) break; JetType correspondingSupertype = TypeCheckingProcedure.findCorrespondingSupertype(subjectType, constrainingType); if (correspondingSupertype != null) { subjectType = correspondingSupertype; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java index 91356a5927f..d7a0b9db77d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/CompileTimeConstantResolver.java @@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.psi.JetVisitorVoid; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.List; @@ -314,7 +314,7 @@ public class CompileTimeConstantResolver { } private boolean noExpectedType(JetType expectedType) { - return expectedType == TypeUtils.NO_EXPECTED_TYPE || JetStandardClasses.isUnit(expectedType) || ErrorUtils.isErrorType(expectedType); + return expectedType == TypeUtils.NO_EXPECTED_TYPE || KotlinBuiltIns.getInstance().isUnit(expectedType) || ErrorUtils.isErrorType(expectedType); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NullValue.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NullValue.java index bbf93922d2f..75c6bab5952 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NullValue.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/constants/NullValue.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.constants; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationArgumentVisitor; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lang.types.JetType; @@ -40,7 +40,7 @@ public class NullValue implements CompileTimeConstant { @NotNull @Override public JetType getType(@NotNull JetStandardLibrary standardLibrary) { - return JetStandardClasses.getNullableNothingType(); + return KotlinBuiltIns.getInstance().getNullableNothingType(); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyTypeParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyTypeParameterDescriptor.java index 1ac60fe0a68..f4960abbb93 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyTypeParameterDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyTypeParameterDescriptor.java @@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; import org.jetbrains.jet.util.lazy.LazyValue; @@ -103,7 +103,7 @@ public class LazyTypeParameterDescriptor implements TypeParameterDescriptor, Laz } if (upperBounds.isEmpty()) { - upperBounds.add(JetStandardClasses.getDefaultBound()); + upperBounds.add(KotlinBuiltIns.getInstance().getDefaultBound()); } } return upperBounds; @@ -155,7 +155,7 @@ public class LazyTypeParameterDescriptor implements TypeParameterDescriptor, Laz assert upperBounds.size() > 0 : "Upper bound list is empty in " + getName(); upperBoundsAsType = TypeUtils.intersect(JetTypeChecker.INSTANCE, upperBounds); if (upperBoundsAsType == null) { - upperBoundsAsType = JetStandardClasses.getNothingType(); + upperBoundsAsType = KotlinBuiltIns.getInstance().getNothingType(); } } return upperBoundsAsType; @@ -170,7 +170,7 @@ public class LazyTypeParameterDescriptor implements TypeParameterDescriptor, Laz @NotNull @Override public JetType getLowerBoundsAsType() { - return JetStandardClasses.getNothingType(); + return KotlinBuiltIns.getInstance().getNothingType(); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ScriptReceiver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ScriptReceiver.java index 3cb869e5e2b..97fe3b0f2a3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ScriptReceiver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/ScriptReceiver.java @@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; /** * @author Stepan Koltsov @@ -45,7 +45,7 @@ public class ScriptReceiver implements ThisReceiverDescriptor { @Override public JetType getType() { // not sure - return JetStandardClasses.getAnyType(); + return KotlinBuiltIns.getInstance().getAnyType(); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/CommonSupertypes.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/CommonSupertypes.java index f977f335d72..58457ab90d7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/CommonSupertypes.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/CommonSupertypes.java @@ -25,7 +25,7 @@ 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.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.utils.DFS; import java.util.*; @@ -47,7 +47,7 @@ public class CommonSupertypes { for (Iterator iterator = typeSet.iterator(); iterator.hasNext();) { JetType type = iterator.next(); assert type != null; - if (JetStandardClasses.isNothingOrNullableNothing(type)) { + if (KotlinBuiltIns.getInstance().isNothingOrNullableNothing(type)) { iterator.remove(); } nullable |= type.isNullable(); @@ -56,7 +56,7 @@ public class CommonSupertypes { // Everything deleted => it's Nothing or Nothing? if (typeSet.isEmpty()) { // TODO : attributes - return nullable ? JetStandardClasses.getNullableNothingType() : JetStandardClasses.getNothingType(); + return nullable ? KotlinBuiltIns.getInstance().getNullableNothingType() : KotlinBuiltIns.getInstance().getNothingType(); } if (typeSet.size() == 1) { @@ -199,7 +199,7 @@ public class CommonSupertypes { } // TODO : attributes? - JetScope newScope = JetStandardClasses.STUB; + JetScope newScope = KotlinBuiltIns.getInstance().STUB; DeclarationDescriptor declarationDescriptor = constructor.getDeclarationDescriptor(); if (declarationDescriptor instanceof ClassDescriptor) { newScope = ((ClassDescriptor) declarationDescriptor).getMemberScope(newProjections); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java index dcbb1c34475..77919ae3926 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java @@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.error.ErrorSimpleFunctionDescriptorImpl; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.*; @@ -227,7 +227,7 @@ public class ErrorUtils { } private static JetType createErrorTypeWithCustomDebugName(JetScope memberScope, String debugName) { - return new ErrorTypeImpl(new TypeConstructorImpl(ERROR_CLASS, Collections.emptyList(), false, debugName, Collections.emptyList(), Collections.singleton(JetStandardClasses.getAnyType())), memberScope); + return new ErrorTypeImpl(new TypeConstructorImpl(ERROR_CLASS, Collections.emptyList(), false, debugName, Collections.emptyList(), Collections.singleton(KotlinBuiltIns.getInstance().getAnyType())), memberScope); } public static JetType createWrongVarianceErrorType(TypeProjection value) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/SubstitutionUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/SubstitutionUtils.java index 7fe9ae8a56d..939a931fe19 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/SubstitutionUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/SubstitutionUtils.java @@ -21,7 +21,7 @@ import com.google.common.collect.Multimap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.util.CommonSuppliers; import java.util.HashMap; @@ -81,7 +81,7 @@ public class SubstitutionUtils { fullSubstitution.put(typeParameterDescriptor.getTypeConstructor(), substitutedTypeProjection); } } - if (JetStandardClasses.isNothingOrNullableNothing(context)) return; + if (KotlinBuiltIns.getInstance().isNothingOrNullableNothing(context)) return; for (JetType supertype : context.getConstructor().getSupertypes()) { fillInDeepSubstitutor(supertype, substitutor, substitution, fullSubstitution); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java index b92cae7e00a..3ef635d6e38 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeSubstitutor.java @@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.List; import java.util.Map; @@ -141,7 +141,7 @@ public class TypeSubstitutor { assertRecursionDepth(recursionDepth, originalProjection, substitution); // The type is within the substitution range, i.e. T or T? JetType type = originalProjection.getType(); - if (JetStandardClasses.isNothing(type) || ErrorUtils.isErrorType(type)) return originalProjection; + if (KotlinBuiltIns.getInstance().isNothing(type) || ErrorUtils.isErrorType(type)) return originalProjection; TypeProjection replacement = substitution.get(type.getConstructor()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java index 380f13377b5..753776bb9c7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java @@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintType; import org.jetbrains.jet.lang.resolve.scopes.ChainedScope; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.*; @@ -104,7 +104,7 @@ public class TypeUtils { @Nullable public static JetType intersect(@NotNull JetTypeChecker typeChecker, @NotNull Set types) { if (types.isEmpty()) { - return JetStandardClasses.getNullableAnyType(); + return KotlinBuiltIns.getInstance().getNullableAnyType(); } if (types.size() == 1) { @@ -117,13 +117,13 @@ public class TypeUtils { boolean nothingTypePresent = false; List nullabilityStripped = Lists.newArrayList(); for (JetType type : types) { - nothingTypePresent |= JetStandardClasses.isNothingOrNullableNothing(type); + nothingTypePresent |= KotlinBuiltIns.getInstance().isNothingOrNullableNothing(type); allNullable &= type.isNullable(); nullabilityStripped.add(makeNotNullable(type)); } if (nothingTypePresent) { - return allNullable ? JetStandardClasses.getNullableNothingType() : JetStandardClasses.getNothingType(); + return allNullable ? KotlinBuiltIns.getInstance().getNullableNothingType() : KotlinBuiltIns.getInstance().getNothingType(); } // Now we remove types that have subtypes in the list diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedure.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedure.java index 709503f8973..debad9b6218 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedure.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedure.java @@ -20,7 +20,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.List; @@ -55,7 +55,7 @@ public class TypeCheckingProcedure { private static JetType getInType(TypeParameterDescriptor parameter, TypeProjection argument) { boolean isOutProjected = argument.getProjectionKind() == OUT_VARIANCE || parameter.getVariance() == OUT_VARIANCE; - return isOutProjected ? JetStandardClasses.getNothingType() : argument.getType(); + return isOutProjected ? KotlinBuiltIns.getInstance().getNothingType() : argument.getType(); } private final TypingConstraints constraints; @@ -164,7 +164,7 @@ public class TypeCheckingProcedure { } subtype = TypeUtils.makeNotNullable(subtype); supertype = TypeUtils.makeNotNullable(supertype); - if (JetStandardClasses.isNothingOrNullableNothing(subtype)) { + if (KotlinBuiltIns.getInstance().isNothingOrNullableNothing(subtype)) { return true; } @Nullable JetType closestSupertype = findCorrespondingSupertype(subtype, supertype); 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 b83a8faa5a4..677687c40a7 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 @@ -45,7 +45,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.resolve.scopes.receivers.ThisReceiverDescriptor; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lexer.JetTokens; @@ -369,14 +369,14 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { for (JetExpression entry : entries) { types.add(context.expressionTypingServices.safeGetType(context.scope, entry, NO_EXPECTED_TYPE, context.dataFlowInfo, context.trace)); // TODO } - if (context.expectedType != NO_EXPECTED_TYPE && JetStandardClasses.isTupleType(context.expectedType)) { + if (context.expectedType != NO_EXPECTED_TYPE && KotlinBuiltIns.getInstance().isTupleType(context.expectedType)) { List enrichedTypes = checkArgumentTypes(types, entries, context.expectedType.getArguments(), context); if (enrichedTypes != types) { - return JetTypeInfo.create(JetStandardClasses.getTupleType(enrichedTypes), context.dataFlowInfo); + return JetTypeInfo.create(KotlinBuiltIns.getInstance().getTupleType(enrichedTypes), context.dataFlowInfo); } } // TODO : labels - return DataFlowUtils.checkType(JetStandardClasses.getTupleType(types), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getTupleType(types), expression, context, context.dataFlowInfo); } @NotNull @@ -481,7 +481,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { else { // supertypes may be empty when all the supertypes are error types (are not resolved, for example) JetType type = supertypes.isEmpty() - ? JetStandardClasses.getAnyType() + ? KotlinBuiltIns.getInstance().getAnyType() : supertypes.iterator().next(); result = substitutor.substitute(type, Variance.INVARIANT); } @@ -565,7 +565,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { //TODO move further if (!(receiverType instanceof NamespaceType) && expression.getOperationSign() == JetTokens.SAFE_ACCESS) { - if (selectorReturnType != null && !selectorReturnType.isNullable() && !JetStandardClasses.isUnit(selectorReturnType)) { + if (selectorReturnType != null && !selectorReturnType.isNullable() && !KotlinBuiltIns.getInstance().isUnit(selectorReturnType)) { if (receiverType.isNullable()) { selectorReturnType = TypeUtils.makeNullable(selectorReturnType); } @@ -847,8 +847,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { JetType returnType = resolutionResults.getResultingDescriptor().getReturnType(); JetType result; if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) { - if (JetTypeChecker.INSTANCE.isSubtypeOf(returnType, JetStandardClasses.getUnitType())) { - result = ErrorUtils.createErrorType(JetStandardClasses.UNIT_ALIAS.getName()); + if (JetTypeChecker.INSTANCE.isSubtypeOf(returnType, KotlinBuiltIns.getInstance().getUnitType())) { + result = ErrorUtils.createErrorType(KotlinBuiltIns.getInstance().UNIT_ALIAS.getName()); context.trace.report(INC_DEC_SHOULD_NOT_RETURN_UNIT.on(operationSign)); } else { @@ -994,7 +994,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { ExpressionReceiver receiver = ExpressionTypingUtils.safeGetExpressionReceiver(facade, left, context.replaceScope(context.scope)); OverloadResolutionResults resolutionResults = context.resolveExactSignature( receiver, name, - Collections.singletonList(JetStandardClasses.getNullableAnyType())); + Collections.singletonList(KotlinBuiltIns.getInstance().getNullableAnyType())); if (resolutionResults.isSuccess()) { FunctionDescriptor equals = resolutionResults.getResultingCall().getResultingDescriptor(); context.trace.record(REFERENCE_TARGET, operationSign, equals); 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 096c1c0f2a6..78be4f93f62 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 @@ -29,7 +29,7 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.util.lazy.LazyValueWithDefault; import org.jetbrains.jet.util.slicedmap.WritableSlice; @@ -97,7 +97,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { if (bodyExpression == null) return null; JetType expectedType = context.expectedType; - boolean functionTypeExpected = expectedType != TypeUtils.NO_EXPECTED_TYPE && JetStandardClasses.isFunctionType(expectedType); + boolean functionTypeExpected = expectedType != TypeUtils.NO_EXPECTED_TYPE && KotlinBuiltIns.getInstance().isFunctionType(expectedType); SimpleFunctionDescriptorImpl functionDescriptor = createFunctionDescriptor(expression, context, functionTypeExpected); @@ -120,7 +120,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { } else { if (functionTypeExpected) { - returnType = JetStandardClasses.getReturnTypeFromFunctionType(expectedType); + returnType = KotlinBuiltIns.getInstance().getReturnTypeFromFunctionType(expectedType); } returnType = context.expressionTypingServices.getBlockReturnedType(functionInnerScope, bodyExpression, CoercionStrategy.COERCION_TO_UNIT, context.replaceExpectedType(returnType).replaceBindingTrace(temporaryTrace), temporaryTrace).getType(); @@ -136,14 +136,14 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { functionDescriptor.setReturnType(safeReturnType); if (!functionLiteral.hasDeclaredReturnType() && functionTypeExpected) { - JetType expectedReturnType = JetStandardClasses.getReturnTypeFromFunctionType(expectedType); - if (JetStandardClasses.isUnit(expectedReturnType)) { - functionDescriptor.setReturnType(JetStandardClasses.getUnitType()); - return DataFlowUtils.checkType(JetStandardClasses.getFunctionType(Collections.emptyList(), receiver, parameterTypes, JetStandardClasses.getUnitType()), expression, context, context.dataFlowInfo); + JetType expectedReturnType = KotlinBuiltIns.getInstance().getReturnTypeFromFunctionType(expectedType); + if (KotlinBuiltIns.getInstance().isUnit(expectedReturnType)) { + functionDescriptor.setReturnType(KotlinBuiltIns.getInstance().getUnitType()); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getFunctionType(Collections.emptyList(), receiver, parameterTypes, KotlinBuiltIns.getInstance().getUnitType()), expression, context, context.dataFlowInfo); } } - return DataFlowUtils.checkType(JetStandardClasses.getFunctionType(Collections.emptyList(), receiver, parameterTypes, safeReturnType), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getFunctionType(Collections.emptyList(), receiver, parameterTypes, safeReturnType), expression, context, context.dataFlowInfo); } private SimpleFunctionDescriptorImpl createFunctionDescriptor(JetFunctionLiteralExpression expression, ExpressionTypingContext context, boolean functionTypeExpected) { @@ -157,7 +157,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { JetType effectiveReceiverType; if (receiverTypeRef == null) { if (functionTypeExpected) { - effectiveReceiverType = JetStandardClasses.getReceiverType(context.expectedType); + effectiveReceiverType = KotlinBuiltIns.getInstance().getReceiverType(context.expectedType); } else { effectiveReceiverType = null; @@ -185,7 +185,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { List declaredValueParameters = functionLiteral.getValueParameters(); List expectedValueParameters = (functionTypeExpected) - ? JetStandardClasses.getValueParameters(functionDescriptor, context.expectedType) + ? KotlinBuiltIns.getInstance().getValueParameters(functionDescriptor, context.expectedType) : null; boolean hasDeclaredValueParameters = functionLiteral.getValueParameterList() != null; 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 a3c5164af49..a897c048526 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 @@ -42,7 +42,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.TransientReceiver; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.util.slicedmap.WritableSlice; @@ -100,12 +100,12 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetTypeInfo typeInfo = context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(thenScope, Collections.singletonList(thenBranch), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(thenInfo), context.trace); JetType type = typeInfo.getType(); DataFlowInfo dataFlowInfo; - if (type != null && JetStandardClasses.isNothing(type)) { + if (type != null && KotlinBuiltIns.getInstance().isNothing(type)) { dataFlowInfo = elseInfo; } else { dataFlowInfo = typeInfo.getDataFlowInfo().or(elseInfo); } - return DataFlowUtils.checkImplicitCast(DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType), expression, contextWithExpectedType, isStatement, dataFlowInfo); + return DataFlowUtils.checkImplicitCast(DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, contextWithExpectedType), expression, contextWithExpectedType, isStatement, dataFlowInfo); } return JetTypeInfo.create(null, context.dataFlowInfo); } @@ -113,12 +113,12 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetTypeInfo typeInfo = context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(elseScope, Collections.singletonList(elseBranch), CoercionStrategy.NO_COERCION, context.replaceDataFlowInfo(elseInfo), context.trace); JetType type = typeInfo.getType(); DataFlowInfo dataFlowInfo; - if (type != null && JetStandardClasses.isNothing(type)) { + if (type != null && KotlinBuiltIns.getInstance().isNothing(type)) { dataFlowInfo = thenInfo; } else { dataFlowInfo = typeInfo.getDataFlowInfo().or(thenInfo); } - return DataFlowUtils.checkImplicitCast(DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType), expression, contextWithExpectedType, isStatement, dataFlowInfo); + return DataFlowUtils.checkImplicitCast(DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, contextWithExpectedType), expression, contextWithExpectedType, isStatement, dataFlowInfo); } CoercionStrategy coercionStrategy = isStatement ? CoercionStrategy.COERCION_TO_UNIT : CoercionStrategy.NO_COERCION; JetTypeInfo thenTypeInfo = context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(thenScope, Collections.singletonList(thenBranch), coercionStrategy, contextWithExpectedType.replaceDataFlowInfo(thenInfo), context.trace); @@ -128,8 +128,8 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { DataFlowInfo thenDataFlowInfo = thenTypeInfo.getDataFlowInfo(); DataFlowInfo elseDataFlowInfo = elseTypeInfo.getDataFlowInfo(); - boolean jumpInThen = thenType != null && JetStandardClasses.isNothing(thenType); - boolean jumpInElse = elseType != null && JetStandardClasses.isNothing(elseType); + boolean jumpInThen = thenType != null && KotlinBuiltIns.getInstance().isNothing(thenType); + boolean jumpInElse = elseType != null && KotlinBuiltIns.getInstance().isNothing(elseType); JetTypeInfo result; if (thenType == null && elseType == null) { @@ -172,7 +172,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { else { dataFlowInfo = context.dataFlowInfo; } - return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType, dataFlowInfo); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, contextWithExpectedType, dataFlowInfo); } private boolean containsBreak(final JetLoopExpression loopExpression, final ExpressionTypingContext context) { @@ -242,7 +242,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { else { dataFlowInfo = context.dataFlowInfo; } - return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType, dataFlowInfo); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, contextWithExpectedType, dataFlowInfo); } @Override @@ -285,7 +285,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { context.expressionTypingServices.getBlockReturnedTypeWithWritableScope(loopScope, Collections.singletonList(body), CoercionStrategy.NO_COERCION, context, context.trace); } - return DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, contextWithExpectedType, context.dataFlowInfo); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, contextWithExpectedType, context.dataFlowInfo); } private static VariableDescriptor createLoopParameterDescriptor( @@ -442,7 +442,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetType throwableType = JetStandardLibrary.getInstance().getThrowable().getDefaultType(); facade.getTypeInfo(thrownExpression, context.replaceExpectedType(throwableType).replaceScope(context.scope)); } - return DataFlowUtils.checkType(JetStandardClasses.getNothingType(), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo); } @Override @@ -498,22 +498,22 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { facade.getTypeInfo(returnedExpression, context.replaceExpectedType(expectedType).replaceScope(context.scope)); } else { - if (expectedType != TypeUtils.NO_EXPECTED_TYPE && expectedType != null && !JetStandardClasses.isUnit(expectedType)) { + if (expectedType != TypeUtils.NO_EXPECTED_TYPE && expectedType != null && !KotlinBuiltIns.getInstance().isUnit(expectedType)) { context.trace.report(RETURN_TYPE_MISMATCH.on(expression, expectedType)); } } - return DataFlowUtils.checkType(JetStandardClasses.getNothingType(), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo); } @Override public JetTypeInfo visitBreakExpression(JetBreakExpression expression, ExpressionTypingContext context) { context.labelResolver.resolveLabel(expression, context); - return DataFlowUtils.checkType(JetStandardClasses.getNothingType(), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo); } @Override public JetTypeInfo visitContinueExpression(JetContinueExpression expression, ExpressionTypingContext context) { context.labelResolver.resolveLabel(expression, context); - return DataFlowUtils.checkType(JetStandardClasses.getNothingType(), expression, context, context.dataFlowInfo); + return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo); } } 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 d33b36fdadd..f001bc864b3 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 @@ -30,7 +30,7 @@ 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.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; import static org.jetbrains.jet.lang.diagnostics.Errors.*; @@ -168,11 +168,11 @@ public class DataFlowUtils { @Nullable public static JetType checkStatementType(@NotNull JetExpression expression, @NotNull ExpressionTypingContext context) { - if (context.expectedType != TypeUtils.NO_EXPECTED_TYPE && !JetStandardClasses.isUnit(context.expectedType) && !ErrorUtils.isErrorType(context.expectedType)) { + if (context.expectedType != TypeUtils.NO_EXPECTED_TYPE && !KotlinBuiltIns.getInstance().isUnit(context.expectedType) && !ErrorUtils.isErrorType(context.expectedType)) { context.trace.report(EXPECTED_TYPE_MISMATCH.on(expression, context.expectedType)); return null; } - return JetStandardClasses.getUnitType(); + return KotlinBuiltIns.getInstance().getUnitType(); } @NotNull @@ -183,7 +183,7 @@ public class DataFlowUtils { @Nullable public static JetType checkImplicitCast(@Nullable JetType expressionType, @NotNull JetExpression expression, @NotNull ExpressionTypingContext context, boolean isStatement) { if (expressionType != null && context.expectedType == TypeUtils.NO_EXPECTED_TYPE && !isStatement && - (JetStandardClasses.isUnit(expressionType) || JetStandardClasses.isAny(expressionType))) { + (KotlinBuiltIns.getInstance().isUnit(expressionType) || KotlinBuiltIns.getInstance().isAny(expressionType))) { context.trace.report(IMPLICIT_CAST_TO_UNIT_OR_ANY.on(expression, expressionType)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java index aa5f2b19ff6..075ce0d8d99 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingServices.java @@ -39,7 +39,7 @@ import org.jetbrains.jet.lang.types.CommonSupertypes; 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.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; import javax.inject.Inject; @@ -142,7 +142,7 @@ public class ExpressionTypingServices { Map typeMap = collectReturnedExpressionsWithTypes(trace, outerScope, function, functionDescriptor); Collection types = typeMap.values(); return types.isEmpty() - ? JetStandardClasses.getNothingType() + ? KotlinBuiltIns.getInstance().getNothingType() : CommonSupertypes.commonSupertype(types); } @@ -200,7 +200,7 @@ public class ExpressionTypingServices { JetTypeInfo r; if (block.isEmpty()) { - r = DataFlowUtils.checkType(JetStandardClasses.getUnitType(), expression, context, context.dataFlowInfo); + r = DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getUnitType(), expression, context, context.dataFlowInfo); } else { r = getBlockReturnedTypeWithWritableScope(scope, block, coercionStrategyForLastExpression, context, trace); @@ -272,7 +272,7 @@ public class ExpressionTypingServices { @SuppressWarnings("SuspiciousMethodCalls") JetTypeInfo getBlockReturnedTypeWithWritableScope(@NotNull WritableScope scope, @NotNull List block, @NotNull CoercionStrategy coercionStrategyForLastExpression, ExpressionTypingContext context, BindingTrace trace) { if (block.isEmpty()) { - return JetTypeInfo.create(JetStandardClasses.getUnitType(), context.dataFlowInfo); + return JetTypeInfo.create(KotlinBuiltIns.getInstance().getUnitType(), context.dataFlowInfo); } ExpressionTypingInternals blockLevelVisitor = ExpressionTypingVisitorDispatcher.createForBlock(scope); @@ -289,7 +289,7 @@ public class ExpressionTypingServices { //TODO constructor assert context.expectedType != FORBIDDEN : "" if (!iterator.hasNext()) { if (context.expectedType != NO_EXPECTED_TYPE) { - if (coercionStrategyForLastExpression == CoercionStrategy.COERCION_TO_UNIT && JetStandardClasses.isUnit(context.expectedType)) { + if (coercionStrategyForLastExpression == CoercionStrategy.COERCION_TO_UNIT && KotlinBuiltIns.getInstance().isUnit(context.expectedType)) { // This implements coercion to Unit TemporaryBindingTrace temporaryTraceExpectingUnit = TemporaryBindingTrace.create(trace); final boolean[] mismatch = new boolean[1]; @@ -334,8 +334,8 @@ public class ExpressionTypingServices { } if (mightBeUnit) { // ExpressionTypingVisitorForStatements should return only null or Unit for declarations and assignments - assert result.getType() == null || JetStandardClasses.isUnit(result.getType()); - result = JetTypeInfo.create(JetStandardClasses.getUnitType(), newContext.dataFlowInfo); + assert result.getType() == null || KotlinBuiltIns.getInstance().isUnit(result.getType()); + result = JetTypeInfo.create(KotlinBuiltIns.getInstance().getUnitType(), newContext.dataFlowInfo); } } } 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 26855ed2767..0d555c62668 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 @@ -43,7 +43,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.util.slicedmap.WritableSlice; @@ -121,7 +121,7 @@ public class ExpressionTypingUtils { return JetStandardLibrary.getInstance().getCharType(); } else if (constantType == JetNodeTypes.NULL) { - return JetStandardClasses.getNullableNothingType(); + return KotlinBuiltIns.getInstance().getNullableNothingType(); } else { throw new IllegalArgumentException("Unsupported constant type: " + constantType); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java index a10414495bf..83bf6de71cf 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java @@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.types.JetTypeInfo; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lexer.JetTokens; @@ -69,7 +69,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito @Nullable private JetType checkAssignmentType(@Nullable JetType assignmentType, @NotNull JetBinaryExpression expression, @NotNull ExpressionTypingContext context) { - if (assignmentType != null && !JetStandardClasses.isUnit(assignmentType) && context.expectedType != TypeUtils.NO_EXPECTED_TYPE && + if (assignmentType != null && !KotlinBuiltIns.getInstance().isUnit(assignmentType) && context.expectedType != TypeUtils.NO_EXPECTED_TYPE && TypeUtils.equalTypes(context.expectedType, assignmentType)) { context.trace.report(Errors.ASSIGNMENT_TYPE_MISMATCH.on(expression, context.expectedType)); return null; @@ -243,7 +243,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito } else if (assignmentOperationType != null) { assignmentOperationTrace.commit(); - if (!JetStandardClasses.isUnit(assignmentOperationType)) { + if (!KotlinBuiltIns.getInstance().isUnit(assignmentOperationType)) { context.trace.report(ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT.on(operationSign, assignmentOperationDescriptors.getResultingDescriptor(), operationSign)); } } 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 23e69de0113..4650e779f45 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 @@ -29,7 +29,7 @@ import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowValueFactory; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.Collections; @@ -294,7 +294,7 @@ public class PatternMatchingTypingVisitor extends ExpressionTypingVisitor { } // check if the pattern is essentially a 'null' expression - if (type == JetStandardClasses.getNullableNothingType() && !subjectType.isNullable()) { + if (type == KotlinBuiltIns.getInstance().getNullableNothingType() && !subjectType.isNullable()) { context.trace.report(SENSELESS_NULL_IN_WHEN.on(reportErrorOn)); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/PrimitiveType.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/PrimitiveType.java index d54aa872d9b..41e6b69afcd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/PrimitiveType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/PrimitiveType.java @@ -49,9 +49,10 @@ public enum PrimitiveType { this.typeName = Name.identifier(typeName); this.arrayTypeName = Name.identifier(typeName + "Array"); this.rangeTypeName = Name.identifier(typeName + "Range"); - this.className = JetStandardClasses.STANDARD_CLASSES_FQNAME.child(this.typeName); - this.arrayClassName = JetStandardClasses.STANDARD_CLASSES_FQNAME.child(this.arrayTypeName); - this.rangeClassName = JetStandardClasses.STANDARD_CLASSES_FQNAME.child(this.rangeTypeName); + FqName builtInsPackageFqName = KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME; + this.className = builtInsPackageFqName.child(this.typeName); + this.arrayClassName = builtInsPackageFqName.child(this.arrayTypeName); + this.rangeClassName = builtInsPackageFqName.child(this.rangeTypeName); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java index c51a752d71c..94f9b7dec9c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java +++ b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java @@ -28,7 +28,7 @@ import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.lang.types.Variance; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; import java.util.*; @@ -113,13 +113,13 @@ public class DescriptorRenderer implements Renderer { else if (ErrorUtils.isErrorType(type)) { return escape(type.toString()); } - else if (JetStandardClasses.isUnit(type)) { - return escape(JetStandardClasses.UNIT_ALIAS + (type.isNullable() ? "?" : "")); + else if (KotlinBuiltIns.getInstance().isUnit(type)) { + return escape(KotlinBuiltIns.getInstance().UNIT_ALIAS + (type.isNullable() ? "?" : "")); } - else if (JetStandardClasses.isTupleType(type)) { + else if (KotlinBuiltIns.getInstance().isTupleType(type)) { return escape(renderTupleType(type, shortNamesOnly)); } - else if (JetStandardClasses.isFunctionType(type)) { + else if (KotlinBuiltIns.getInstance().isFunctionType(type)) { return escape(renderFunctionType(type, shortNamesOnly)); } else { @@ -196,7 +196,7 @@ public class DescriptorRenderer implements Renderer { protected String renderTupleType(JetType type, boolean shortNamesOnly) { StringBuilder sb = new StringBuilder("#("); - appendTypes(sb, JetStandardClasses.getTupleElementTypes(type), shortNamesOnly); + appendTypes(sb, KotlinBuiltIns.getInstance().getTupleElementTypes(type), shortNamesOnly); sb.append(")"); if (type.isNullable()) { @@ -209,16 +209,16 @@ public class DescriptorRenderer implements Renderer { private String renderFunctionType(JetType type, boolean shortNamesOnly) { StringBuilder sb = new StringBuilder(); - JetType receiverType = JetStandardClasses.getReceiverType(type); + JetType receiverType = KotlinBuiltIns.getInstance().getReceiverType(type); if (receiverType != null) { sb.append(renderType(receiverType, shortNamesOnly)); sb.append("."); } sb.append("("); - appendTypeProjections(sb, JetStandardClasses.getParameterTypeProjectionsFromFunctionType(type), shortNamesOnly); + appendTypeProjections(sb, KotlinBuiltIns.getInstance().getParameterTypeProjectionsFromFunctionType(type), shortNamesOnly); sb.append(") -> "); - sb.append(renderType(JetStandardClasses.getReturnTypeFromFunctionType(type), shortNamesOnly)); + sb.append(renderType(KotlinBuiltIns.getInstance().getReturnTypeFromFunctionType(type), shortNamesOnly)); if (type.isNullable()) { return "(" + sb + ")?"; @@ -565,9 +565,9 @@ public class DescriptorRenderer implements Renderer { renderName(descriptor, builder); renderTypeParameters(descriptor.getTypeConstructor().getParameters(), builder); } - if (!descriptor.equals(JetStandardClasses.getNothing())) { + if (!descriptor.equals(KotlinBuiltIns.getInstance().getNothing())) { Collection supertypes = descriptor.getTypeConstructor().getSupertypes(); - if (supertypes.isEmpty() || supertypes.size() == 1 && JetStandardClasses.isAny(supertypes.iterator().next())) { + if (supertypes.isEmpty() || supertypes.size() == 1 && KotlinBuiltIns.getInstance().isAny(supertypes.iterator().next())) { } else { builder.append(" : "); @@ -599,14 +599,14 @@ public class DescriptorRenderer implements Renderer { renderName(descriptor, builder); if (descriptor.getUpperBounds().size() == 1) { JetType upperBound = descriptor.getUpperBounds().iterator().next(); - if (upperBound != JetStandardClasses.getDefaultBound()) { + if (upperBound != KotlinBuiltIns.getInstance().getDefaultBound()) { builder.append(" : ").append(renderType(upperBound)); } } else if (topLevel) { boolean first = true; for (JetType upperBound : descriptor.getUpperBounds()) { - if (upperBound.equals(JetStandardClasses.getDefaultBound())) { + if (upperBound.equals(KotlinBuiltIns.getInstance().getDefaultBound())) { continue; } if (first) { diff --git a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java index 2ef3f584f2f..eaec8477027 100644 --- a/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java +++ b/compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java @@ -51,7 +51,7 @@ import org.jetbrains.jet.lang.resolve.java.JetFilesProvider; import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetLanguage; import javax.swing.*; @@ -94,7 +94,7 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa @Nullable public static JetLightClass create(PsiManager manager, JetFile file, FqName qualifiedName) { - return JetStandardClasses.isStandardClass(qualifiedName) ? null : new JetLightClass(manager, file, qualifiedName); + return KotlinBuiltIns.getInstance().isStandardClass(qualifiedName) ? null : new JetLightClass(manager, file, qualifiedName); } @Override diff --git a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java index 1d0868a805f..12e037114a7 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java +++ b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java @@ -37,7 +37,7 @@ import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.lang.types.Variance; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.junit.Assert; import org.junit.ComparisonFailure; @@ -732,7 +732,7 @@ public class NamespaceComparator { sb.append(">"); } - if (JetStandardClasses.getNothing() != klass && !klass.getTypeConstructor().getSupertypes().isEmpty()) { + if (KotlinBuiltIns.getInstance().getNothing() != klass && !klass.getTypeConstructor().getSupertypes().isEmpty()) { sb.append(" : "); new TypeSerializer(sb).serializeCommaSeparated(new ArrayList(klass.getTypeConstructor().getSupertypes())); } diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 3f37f6a90d5..83fb464c1e3 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -45,7 +45,7 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.lexer.JetTokens; @@ -117,15 +117,15 @@ public class JetTypeCheckerTest extends JetLiteFixture { assertType("\"d\"", library.getStringType()); assertType("\"\"\"d\"\"\"", library.getStringType()); - assertType("#()", JetStandardClasses.getUnitType()); + assertType("#()", KotlinBuiltIns.getInstance().getUnitType()); - assertType("null", JetStandardClasses.getNullableNothingType()); + assertType("null", KotlinBuiltIns.getInstance().getNullableNothingType()); } public void testTupleConstants() throws Exception { - assertType("#()", JetStandardClasses.getUnitType()); + assertType("#()", KotlinBuiltIns.getInstance().getUnitType()); - assertType("#(1, 'a')", JetStandardClasses.getTupleType(library.getIntType(), library.getCharType())); + assertType("#(1, 'a')", KotlinBuiltIns.getInstance().getTupleType(library.getIntType(), library.getCharType())); } public void testTypeInfo() throws Exception { @@ -135,9 +135,9 @@ public class JetTypeCheckerTest extends JetLiteFixture { } public void testJumps() throws Exception { - assertType("throw java.lang.Exception()", JetStandardClasses.getNothingType()); - assertType("continue", JetStandardClasses.getNothingType()); - assertType("break", JetStandardClasses.getNothingType()); + assertType("throw java.lang.Exception()", KotlinBuiltIns.getInstance().getNothingType()); + assertType("continue", KotlinBuiltIns.getInstance().getNothingType()); + assertType("break", KotlinBuiltIns.getInstance().getNothingType()); } public void testIf() throws Exception { @@ -713,7 +713,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { List delegationSpecifiers = classElement.getDelegationSpecifiers(); // TODO : assuming that the hierarchy is acyclic Collection supertypes = delegationSpecifiers.isEmpty() - ? Collections.singleton(JetStandardClasses.getAnyType()) + ? Collections.singleton(KotlinBuiltIns.getInstance().getAnyType()) : descriptorResolver.resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver, JetTestUtils.DUMMY_TRACE, true); // for (JetType supertype: supertypes) { // if (supertype.getConstructor().isSealed()) { diff --git a/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java b/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java index ecd90784c69..1bcb2e49ee6 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java @@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.LinkedList; @@ -54,8 +54,8 @@ public class JetPluginUtil { } public static boolean checkTypeIsStandard(JetType type, Project project) { - if (JetStandardClasses.isAny(type) || JetStandardClasses.isNothingOrNullableNothing(type) || JetStandardClasses.isUnit(type) || - JetStandardClasses.isTupleType(type) || JetStandardClasses.isFunctionType(type)) { + if (KotlinBuiltIns.getInstance().isAny(type) || KotlinBuiltIns.getInstance().isNothingOrNullableNothing(type) || KotlinBuiltIns.getInstance().isUnit(type) || + KotlinBuiltIns.getInstance().isTupleType(type) || KotlinBuiltIns.getInstance().isFunctionType(type)) { return true; } diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java index baa8969242e..ce9368dac7f 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java @@ -44,7 +44,7 @@ import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.plugin.stubindex.JetExtensionFunctionNameIndex; import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex; @@ -120,7 +120,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { */ @NotNull public static Collection getJetOnlyTypes() { - Collection standardTypes = JetStandardClasses.getAllStandardClasses(); + Collection standardTypes = KotlinBuiltIns.getInstance().getAllBuiltInClasses(); standardTypes.addAll( Collections2.transform(JetStandardLibrary.getInstance().getStandardTypes(), new Function() { diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java index b6e1d69ad01..b6dbe8d098e 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java @@ -37,7 +37,7 @@ 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.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade; @@ -99,7 +99,7 @@ public class GotoSuperActionHandler implements CodeInsightActionHandler { List superDeclarations = ContainerUtil.mapNotNull(superDescriptors, new Function() { @Override public PsiElement fun(DeclarationDescriptor descriptor) { - if (JetStandardClasses.getAny() == descriptor) { + if (KotlinBuiltIns.getInstance().getAny() == descriptor) { return null; } return BindingContextUtils.descriptorToDeclaration(bindingContext, descriptor); diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java index 0dc2061822d..bf6ae719dbc 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java @@ -35,7 +35,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade; import org.jetbrains.jet.resolve.DescriptorRenderer; @@ -177,7 +177,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns boolean firstUpperBound = true; for (JetType upperBound : upperBounds) { String upperBoundText = " : " + renderType(upperBound); - if (upperBound != JetStandardClasses.getDefaultBound()) { + if (upperBound != KotlinBuiltIns.getInstance().getDefaultBound()) { if (firstUpperBound) { bodyBuilder.append(upperBoundText); } else { diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceToClassesShortening.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceToClassesShortening.java index c93ee6f2831..bbf168ca690 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceToClassesShortening.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceToClassesShortening.java @@ -23,7 +23,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade; import org.jetbrains.jet.plugin.quickfix.ImportInsertHelper; @@ -79,7 +79,7 @@ public class ReferenceToClassesShortening { } private void compactReferenceToClass(JetUserType userType, ClassDescriptor targetClass) { - if (targetClass == JetStandardClasses.getUnitType().getConstructor().getDeclarationDescriptor()) { + if (targetClass == KotlinBuiltIns.getInstance().getUnitType().getConstructor().getDeclarationDescriptor()) { // do not replace "Unit" with "Tuple0" return; } diff --git a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java index bbc69f4f771..75f57446436 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java @@ -29,7 +29,7 @@ import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetDescriptorIconProvider; import org.jetbrains.jet.plugin.completion.handlers.JetClassInsertHandler; import org.jetbrains.jet.plugin.completion.handlers.JetFunctionInsertHandler; @@ -85,7 +85,7 @@ public final class DescriptorLookupConverter { } else { if (functionDescriptor.getValueParameters().size() == 1 - && JetStandardClasses.isFunctionType(functionDescriptor.getValueParameters().get(0).getType())) { + && KotlinBuiltIns.getInstance().isFunctionType(functionDescriptor.getValueParameters().get(0).getType())) { element = element.withInsertHandler(PARAMS_BRACES_FUNCTION_HANDLER); } else { element = element.withInsertHandler(PARAMS_PARENTHESIS_FUNCTION_HANDLER); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateTuplesInProjectFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateTuplesInProjectFix.java index 8115c0e5d18..82b3c09a57d 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateTuplesInProjectFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/MigrateTuplesInProjectFix.java @@ -36,7 +36,7 @@ import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BodiesResolveContext; import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.project.AnalyzerFacadeProvider; import org.jetbrains.jet.plugin.project.PluginJetFilesProvider; @@ -119,7 +119,7 @@ public class MigrateTuplesInProjectFix extends JetIntentionAction { if (containingDeclaration == null) return; ImmutableSet supportedTupleClasses = - ImmutableSet.of(JetStandardClasses.getTuple(2), JetStandardClasses.getTuple(3)); + ImmutableSet.of(KotlinBuiltIns.getInstance().getTuple(2), KotlinBuiltIns.getInstance().getTuple(3)); //noinspection SuspiciousMethodCalls if (!supportedTupleClasses.contains(containingDeclaration)) return; diff --git a/idea/src/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolver.java b/idea/src/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolver.java index d4888d626f6..fa2ac34eb79 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolver.java +++ b/idea/src/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolver.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.plugin.references; -import com.google.common.collect.Lists; import com.intellij.openapi.components.AbstractProjectComponent; import com.intellij.openapi.project.Project; import com.intellij.openapi.startup.StartupManager; @@ -41,7 +40,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.resolve.DescriptorRenderer; import java.net.URL; @@ -54,7 +53,7 @@ public class StandardLibraryReferenceResolver extends AbstractProjectComponent { private BindingContext bindingContext = null; private final Object lock = new Object(); - private static final FqName TUPLE0_FQ_NAME = DescriptorUtils.getFQName(JetStandardClasses.getTuple(0)).toSafe(); + private static final FqName TUPLE0_FQ_NAME = DescriptorUtils.getFQName(KotlinBuiltIns.getInstance().getTuple(0)).toSafe(); public StandardLibraryReferenceResolver(Project project) { super(project); @@ -78,7 +77,7 @@ public class StandardLibraryReferenceResolver extends AbstractProjectComponent { BindingTraceContext context = new BindingTraceContext(); FakeJetNamespaceDescriptor jetNamespace = new FakeJetNamespaceDescriptor(); - context.record(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, JetStandardClasses.STANDARD_CLASSES_FQNAME, jetNamespace); + context.record(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, KotlinBuiltIns.getInstance().getBuiltInsPackageFqName(), jetNamespace); WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, jetNamespace, RedeclarationHandler.THROW_EXCEPTION, "Builtin classes scope"); @@ -92,7 +91,7 @@ public class StandardLibraryReferenceResolver extends AbstractProjectComponent { scope = new WritableScopeImpl(scope, jetNamespace, RedeclarationHandler.THROW_EXCEPTION, "Builtin classes scope: needed to analyze builtins which depend on Unit type alias"); scope.changeLockLevel(WritableScope.LockLevel.BOTH); - scope.addClassifierAlias(JetStandardClasses.UNIT_ALIAS, tuple0); + scope.addClassifierAlias(KotlinBuiltIns.getInstance().UNIT_ALIAS, tuple0); jetNamespace.setMemberScope(scope); TopDownAnalyzer.processStandardLibraryNamespace(myProject, context, scope, jetNamespace, getJetFiles("jet")); @@ -145,7 +144,7 @@ public class StandardLibraryReferenceResolver extends AbstractProjectComponent { } for (DeclarationDescriptor member : descriptors) { if (renderedOriginal.equals(DescriptorRenderer.TEXT.render(member).replace(TUPLE0_FQ_NAME.getFqName(), - JetStandardClasses.UNIT_ALIAS.getName()))) { + KotlinBuiltIns.getInstance().UNIT_ALIAS.getName()))) { return member; } } @@ -211,7 +210,7 @@ public class StandardLibraryReferenceResolver extends AbstractProjectComponent { super(new NamespaceDescriptorImpl(new ModuleDescriptor(Name.special("")), Collections.emptyList(), Name.special("")), Collections.emptyList(), - JetStandardClasses.STANDARD_CLASSES_NAMESPACE.getName()); + KotlinBuiltIns.getInstance().getBuiltInsPackage().getName()); } void setMemberScope(WritableScope memberScope) { diff --git a/idea/tests/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolverTest.java b/idea/tests/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolverTest.java index f1dab9be946..c2d182d32ac 100644 --- a/idea/tests/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolverTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolverTest.java @@ -23,7 +23,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitorEmptyBodies; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.plugin.PluginTestCaseBase; import java.util.ArrayList; @@ -81,7 +81,7 @@ public class StandardLibraryReferenceResolverTest extends ResolveTestCase { public void testAllReferencesResolved() { StandardLibraryReferenceResolver referenceResolver = getProject().getComponent(StandardLibraryReferenceResolver.class); - for (DeclarationDescriptor descriptor : getAllStandardDescriptors(JetStandardClasses.STANDARD_CLASSES_NAMESPACE)) { + for (DeclarationDescriptor descriptor : getAllStandardDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackage())) { if (descriptor instanceof NamespaceDescriptor && "jet".equals(descriptor.getName().getName())) continue; assertNotNull("Can't resolve " + descriptor, referenceResolver.resolveStandardLibrarySymbol(descriptor)); } diff --git a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java index c3a216985e7..bc6fe937206 100644 --- a/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java +++ b/j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.java @@ -23,7 +23,7 @@ import org.jetbrains.jet.j2k.Converter; import org.jetbrains.jet.j2k.J2KConverterFlags; import org.jetbrains.jet.j2k.ast.*; import org.jetbrains.jet.j2k.util.AstUtil; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.LinkedList; import java.util.List; @@ -62,7 +62,7 @@ public class TypeVisitor extends PsiTypeVisitor implements J2KVisitor { final IdentifierImpl identifier = new IdentifierImpl(name); if (name.equals("void")) { - myResult = new PrimitiveType(new IdentifierImpl(JetStandardClasses.UNIT_ALIAS.getName())); + myResult = new PrimitiveType(new IdentifierImpl(KotlinBuiltIns.getInstance().UNIT_ALIAS.getName())); } else if (Node.PRIMITIVE_TYPES.contains(name)) { myResult = new PrimitiveType(new IdentifierImpl(AstUtil.upperFirstCharacter(name))); diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java b/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java index 916ca121c6d..4b3a6f6da1e 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java @@ -33,7 +33,7 @@ import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.Arrays; @@ -51,7 +51,7 @@ public class JsConfiguration implements ModuleConfiguration { public static final List DEFAULT_IMPORT_PATHS = Arrays.asList( new ImportPath("js.*"), new ImportPath("java.lang.*"), - new ImportPath(JetStandardClasses.STANDARD_CLASSES_FQNAME, true), + new ImportPath(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName(), true), new ImportPath("kotlin.*")); @NotNull diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/FunctionBodyTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/FunctionBodyTranslator.java index e37a6a1e4da..b4d66e270c8 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/FunctionBodyTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/FunctionBodyTranslator.java @@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.psi.JetDeclarationWithBody; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.k2js.translate.context.TranslationContext; import org.jetbrains.k2js.translate.general.AbstractTranslator; import org.jetbrains.k2js.translate.general.Translation; @@ -78,7 +78,7 @@ public final class FunctionBodyTranslator extends AbstractTranslator { private boolean mustAddReturnToGeneratedFunctionBody() { JetType functionReturnType = descriptor.getReturnType(); assert functionReturnType != null : "Function return typed type must be resolved."; - return (!declaration.hasBlockBody()) && (!JetStandardClasses.isUnit(functionReturnType)); + return (!declaration.hasBlockBody()) && (!KotlinBuiltIns.getInstance().isUnit(functionReturnType)); } @NotNull diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsDescriptorUtils.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsDescriptorUtils.java index ca4094d8724..da4018d36ad 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsDescriptorUtils.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsDescriptorUtils.java @@ -29,7 +29,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.expressions.OperatorConventions; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.k2js.translate.context.TranslationContext; @@ -175,7 +175,7 @@ public final class JsDescriptorUtils { @Nullable public static Name getNameIfStandardType(@NotNull JetType type) { ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor(); - if (descriptor != null && descriptor.getContainingDeclaration() == JetStandardClasses.STANDARD_CLASSES_NAMESPACE) { + if (descriptor != null && descriptor.getContainingDeclaration() == KotlinBuiltIns.getInstance().getBuiltInsPackage()) { return descriptor.getName(); }