Remove all deprecated OBJECT$ usages from project code

compiler/backend/src/org/jetbrains/kotlin/codegen/MemberCodegen.java

@@ -365,7 +365,7 @@ public abstract class MemberCodegen<T extends JetElement/* TODO: & JetDeclaratio
         CompileTimeConstant<?> initializerValue;
         if (property.isVar() && initializer != null) {
             BindingTrace tempTrace = TemporaryBindingTrace.create(state.getBindingTrace(), "property initializer");
-            initializerValue = ConstantExpressionEvaluator.OBJECT$.evaluate(initializer, tempTrace, propertyDescriptor.getType());
+            initializerValue = ConstantExpressionEvaluator.evaluate(initializer, tempTrace, propertyDescriptor.getType());
         }
         else {
             initializerValue = propertyDescriptor.getCompileTimeInitializer();

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.java

@@ -203,7 +203,7 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
         if (PackagePartClassUtils.getPackageFilesWithCallables(filesInPackage).isEmpty()) return Collections.emptyList();
 
         //noinspection RedundantTypeArguments
-        return UtilsPackage.<PsiClass>emptyOrSingletonList(KotlinLightClassForPackage.OBJECT$.create(psiManager, packageFqName, scope, filesInPackage));
+        return UtilsPackage.<PsiClass>emptyOrSingletonList(KotlinLightClassForPackage.Factory.create(psiManager, packageFqName, scope, filesInPackage));
     }
 
     @NotNull

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaAnnotationImpl.java

@@ -39,7 +39,7 @@ public class JavaAnnotationImpl extends JavaElementImpl<PsiAnnotation> implement
     @Nullable
     public JavaAnnotationArgument findArgument(@NotNull Name name) {
         PsiAnnotationMemberValue attribute = getPsi().findAttributeValue(name.asString());
-        return attribute == null ? null : JavaAnnotationArgumentImpl.OBJECT$.create(attribute, name);
+        return attribute == null ? null : JavaAnnotationArgumentImpl.Factory.create(attribute, name);
     }
 
     @Override

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaElementCollectionFromPsiArrayUtil.java

@@ -120,7 +120,7 @@ public class JavaElementCollectionFromPsiArrayUtil {
                 String name = psiNameValuePair.getName();
                 PsiAnnotationMemberValue value = psiNameValuePair.getValue();
                 assert value != null : "Annotation argument value cannot be null: " + name;
-                return JavaAnnotationArgumentImpl.OBJECT$.create(value, name == null ? null : Name.identifier(name));
+                return JavaAnnotationArgumentImpl.Factory.create(value, name == null ? null : Name.identifier(name));
             }
         };
     }

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPropertyInitializerEvaluatorImpl.java

@@ -37,7 +37,7 @@ public class JavaPropertyInitializerEvaluatorImpl implements JavaPropertyInitial
         if (evaluatedExpression != null) {
             return ConstantsPackage.createCompileTimeConstant(
                     evaluatedExpression,
-                    ConstantExpressionEvaluator.OBJECT$.isPropertyCompileTimeConstant(descriptor),
+                    ConstantExpressionEvaluator.isPropertyCompileTimeConstant(descriptor),
                     false,
                     true,
                     descriptor.getType());

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/annotationArgumentsImpl.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.Name
 abstract class JavaAnnotationArgumentImpl(
         override val name: Name?
 ) : JavaAnnotationArgument {
-    class object {
+    class object Factory {
         fun create(argument: PsiAnnotationMemberValue, name: Name?): JavaAnnotationArgument {
             val value = JavaPsiFacade.getInstance(argument.getProject()).getConstantEvaluationHelper().computeConstantExpression(argument)
             if (value is Enum<*>) {

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinBinaryClassCache.java

@@ -63,7 +63,7 @@ public final class KotlinBinaryClassCache implements Disposable {
                 @Override
                 public VirtualFileKotlinClass compute() {
                     //noinspection deprecation
-                    return VirtualFileKotlinClass.OBJECT$.create(file);
+                    return VirtualFileKotlinClass.Factory.create(file);
                 }
             });
 

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt

@@ -46,7 +46,7 @@ public class VirtualFileKotlinClass private(
     override fun hashCode() = file.hashCode()
     override fun toString() = "${javaClass.getSimpleName()}: $file"
 
-    class object {
+    class object Factory {
         private val LOG = Logger.getInstance(javaClass<VirtualFileKotlinClass>())
 
         deprecated("Use KotlinBinaryClassCache")

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/JetControlFlowInstructionsGenerator.java

@@ -446,7 +446,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
                 @NotNull Map<PseudoValue, TypePredicate> expectedTypes,
                 @NotNull MagicKind kind
         ) {
-            MagicInstruction instruction = MagicInstruction.OBJECT$.create(
+            MagicInstruction instruction = MagicInstruction.Factory.create(
                     instructionElement, valueElement, getCurrentScope(), inputValues, expectedTypes, kind, valueFactory
             );
             add(instruction);
@@ -456,7 +456,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
         @NotNull
         @Override
         public MergeInstruction merge(@NotNull JetExpression expression, @NotNull List<PseudoValue> inputValues) {
-            MergeInstruction instruction = MergeInstruction.OBJECT$.create(expression, getCurrentScope(), inputValues, valueFactory);
+            MergeInstruction instruction = MergeInstruction.Factory.create(expression, getCurrentScope(), inputValues, valueFactory);
             add(instruction);
             return instruction;
         }
@@ -480,7 +480,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
                 @NotNull Map<PseudoValue, ValueParameterDescriptor> arguments
         ) {
             JetType returnType = resolvedCall.getResultingDescriptor().getReturnType();
-            CallInstruction instruction = CallInstruction.OBJECT$.create(
+            CallInstruction instruction = CallInstruction.Factory.create(
                     valueElement,
                     getCurrentScope(),
                     resolvedCall,
@@ -537,7 +537,7 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd
                 @NotNull Map<PseudoValue, ReceiverValue> receiverValues
         ) {
             AccessTarget accessTarget = resolvedCall != null ? new AccessTarget.Call(resolvedCall) : AccessTarget.BlackBox.INSTANCE$;
-            ReadValueInstruction instruction = ReadValueInstruction.OBJECT$.create(
+            ReadValueInstruction instruction = ReadValueInstruction.Factory.create(
                     expression, getCurrentScope(), accessTarget, receiverValues, valueFactory
             );
             add(instruction);

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/accessInstructions.kt

@@ -75,7 +75,7 @@ public class ReadValueInstruction private (
     override fun createCopy(): InstructionImpl =
             ReadValueInstruction(element, lexicalScope, target, receiverValues, outputValue)
 
-    class object {
+    class object Factory {
         public fun create (
                 element: JetElement,
                 lexicalScope: LexicalScope,

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/instructions/eval/operationInstructions.kt

@@ -79,7 +79,7 @@ public class CallInstruction private(
     override fun toString() =
             renderInstruction("call", "${render(element)}, ${resolvedCall.getResultingDescriptor()!!.getName()}")
 
-    class object {
+    class object Factory {
         fun create (
                 element: JetElement,
                 lexicalScope: LexicalScope,
@@ -115,7 +115,7 @@ public class MagicInstruction(
 
     override fun toString() = renderInstruction("magic[$kind]", render(element))
 
-    class object {
+    class object Factory {
         fun create(
                 element: JetElement,
                 valueElement: JetElement?,
@@ -165,7 +165,7 @@ class MergeInstruction private(
 
     override fun toString() = renderInstruction("merge", render(element))
 
-    class object {
+    class object Factory {
         fun create(
                 element: JetElement,
                 lexicalScope: LexicalScope,

compiler/frontend/src/org/jetbrains/kotlin/kdoc/lexer/KDocTokens.java

@@ -60,7 +60,7 @@ public interface KDocTokens {
     ILazyParseableElementType MARKDOWN_LINK = new ILazyParseableElementType("KDOC_MARKDOWN_LINK", JetLanguage.INSTANCE) {
         @Override
         public ASTNode parseContents(ASTNode chameleon) {
-            return KDocLinkParser.OBJECT$.parseMarkdownLink(this, chameleon);
+            return KDocLinkParser.parseMarkdownLink(this, chameleon);
         }
     };
 

compiler/frontend/src/org/jetbrains/kotlin/kdoc/parser/KDocLinkParser.kt

@@ -23,13 +23,14 @@ import com.intellij.lang.ASTNode
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.lexer.JetLexer
 import com.intellij.lang.PsiBuilderFactory
+import kotlin.platform.*
 
 /**
  * Parses the contents of a Markdown link in KDoc. Uses the standard Kotlin lexer.
  */
 class KDocLinkParser(): PsiParser {
     class object {
-        public fun parseMarkdownLink(root: IElementType, chameleon: ASTNode): ASTNode {
+        platformStatic public fun parseMarkdownLink(root: IElementType, chameleon: ASTNode): ASTNode {
             val parentElement = chameleon.getTreeParent().getPsi()
             val project = parentElement.getProject()
             val builder = PsiBuilderFactory.getInstance().createBuilder(project,

compiler/frontend/src/org/jetbrains/kotlin/psi/JetNameReferenceExpression.java

@@ -48,13 +48,13 @@ public class JetNameReferenceExpression extends JetExpressionImplStub<KotlinName
         if (stub != null) {
             return stub.getReferencedName();
         }
-        return JetSimpleNameExpressionImpl.OBJECT$.getReferencedNameImpl(this);
+        return JetSimpleNameExpressionImpl.Helper.getReferencedNameImpl(this);
     }
 
     @Override
     @NotNull
     public Name getReferencedNameAsName() {
-        return JetSimpleNameExpressionImpl.OBJECT$.getReferencedNameAsNameImpl(this);
+        return JetSimpleNameExpressionImpl.Helper.getReferencedNameAsNameImpl(this);
     }
 
     @Override
@@ -76,7 +76,7 @@ public class JetNameReferenceExpression extends JetExpressionImplStub<KotlinName
     @NotNull
     @Override
     public IElementType getReferencedNameElementType() {
-        return JetSimpleNameExpressionImpl.OBJECT$.getReferencedNameElementTypeImpl(this);
+        return JetSimpleNameExpressionImpl.Helper.getReferencedNameElementTypeImpl(this);
     }
 
     @Override

compiler/frontend/src/org/jetbrains/kotlin/psi/JetSimpleNameExpression.kt

@@ -50,7 +50,7 @@ abstract class JetSimpleNameExpressionImpl(node: ASTNode) : JetExpressionImpl(no
     override fun getReferencedName() = getReferencedNameImpl()
 
     //NOTE: an unfortunate way to share an implementation between stubbed and not stubbed tree
-    class object {
+    class object Helper {
 
         fun JetSimpleNameExpression.getReferencedNameElementTypeImpl(): IElementType {
             return this.getReferencedNameElement().getNode()!!.getElementType()!!

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java

@@ -348,7 +348,7 @@ public class AnnotationResolver {
         for (ValueArgument argument : resolvedValueArgument.getArguments()) {
             JetExpression argumentExpression = argument.getArgumentExpression();
             if (argumentExpression != null) {
-                CompileTimeConstant<?> constant = ConstantExpressionEvaluator.OBJECT$.evaluate(argumentExpression, trace, expectedType);
+                CompileTimeConstant<?> constant = ConstantExpressionEvaluator.evaluate(argumentExpression, trace, expectedType);
                 if (constant instanceof IntegerValueTypeConstant) {
                     JetType defaultType = ((IntegerValueTypeConstant) constant).getType(expectedType);
                     SimpleResolutionContext context =

compiler/frontend/src/org/jetbrains/kotlin/resolve/CompileTimeConstantUtils.java

@@ -130,7 +130,7 @@ public class CompileTimeConstantUtils {
     ) {
         if (expression == null) return false;
         CompileTimeConstant<?> compileTimeConstant =
-                ConstantExpressionEvaluator.OBJECT$.evaluate(expression, trace, KotlinBuiltIns.getInstance().getBooleanType());
+                ConstantExpressionEvaluator.evaluate(expression, trace, KotlinBuiltIns.getInstance().getBooleanType());
         if (!(compileTimeConstant instanceof BooleanValue) || compileTimeConstant.usesVariableAsConstant()) return false;
 
         Boolean value = ((BooleanValue) compileTimeConstant).getValue();

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -1095,7 +1095,7 @@ public class DescriptorResolver {
                 public CompileTimeConstant<?> invoke() {
                     JetExpression initializer = variable.getInitializer();
                     JetType initializerType = expressionTypingServices.safeGetType(scope, initializer, variableType, dataFlowInfo, trace);
-                    CompileTimeConstant<?> constant = ConstantExpressionEvaluator.OBJECT$.evaluate(initializer, trace, initializerType);
+                    CompileTimeConstant<?> constant = ConstantExpressionEvaluator.evaluate(initializer, trace, initializerType);
                     if (constant instanceof IntegerValueTypeConstant) {
                         return EvaluatePackage.createCompileTimeConstantWithType((IntegerValueTypeConstant) constant, initializerType);
                     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/ArgumentTypeResolver.java

@@ -298,6 +298,6 @@ public class ArgumentTypeResolver {
             return;
         }
 
-        ConstantExpressionEvaluator.OBJECT$.evaluate(expression, context.trace, numberType);
+        ConstantExpressionEvaluator.evaluate(expression, context.trace, numberType);
     }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java

@@ -294,7 +294,7 @@ public class CallExpressionResolver {
             context.trace.record(BindingContext.EXPRESSION_TYPE, selectorExpression, selectorReturnType);
         }
 
-        CompileTimeConstant<?> value = ConstantExpressionEvaluator.OBJECT$.evaluate(expression, context.trace, context.expectedType);
+        CompileTimeConstant<?> value = ConstantExpressionEvaluator.evaluate(expression, context.trace, context.expectedType);
         if (value instanceof IntegerValueConstant && ((IntegerValueConstant) value).isPure()) {
             return BasicExpressionTypingVisitor.createCompileTimeConstantTypeInfo(value, expression, context);
         }

compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt

@@ -34,16 +34,17 @@ import java.math.BigInteger
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
+import kotlin.platform.platformStatic
 
 public class ConstantExpressionEvaluator private (val trace: BindingTrace) : JetVisitor<CompileTimeConstant<*>, JetType>() {
 
     class object {
-        public fun evaluate(expression: JetExpression, trace: BindingTrace, expectedType: JetType? = TypeUtils.NO_EXPECTED_TYPE): CompileTimeConstant<*>? {
+        platformStatic public fun evaluate(expression: JetExpression, trace: BindingTrace, expectedType: JetType? = TypeUtils.NO_EXPECTED_TYPE): CompileTimeConstant<*>? {
             val evaluator = ConstantExpressionEvaluator(trace)
             return evaluator.evaluate(expression, expectedType)
         }
 
-        public fun isPropertyCompileTimeConstant(descriptor: VariableDescriptor): Boolean {
+        platformStatic public fun isPropertyCompileTimeConstant(descriptor: VariableDescriptor): Boolean {
             if (descriptor.isVar()) {
                 return false
             }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt

@@ -55,7 +55,7 @@ class LazyFileScope private(
         }
     }
 
-    class object {
+    class object Factory {
         public fun create(
                 resolveSession: ResolveSession,
                 file: JetFile,

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ScopeProvider.java

@@ -100,7 +100,7 @@ public class ScopeProvider implements DeclarationScopeProvider, FileScopeProvide
 
     private LazyFileScope createFileScope(@NotNull JetFile file) {
         TemporaryBindingTrace tempTrace = TemporaryBindingTrace.create(resolveSession.getTrace(), "Transient trace for default imports lazy resolve");
-        return LazyFileScope.OBJECT$.create(
+        return LazyFileScope.Factory.create(
                 resolveSession,
                 file,
                 defaultImports.invoke(),

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -120,7 +120,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
     @Override
     public JetTypeInfo visitConstantExpression(@NotNull JetConstantExpression expression, ExpressionTypingContext context) {
-        CompileTimeConstant<?> value = ConstantExpressionEvaluator.OBJECT$.evaluate(expression, context.trace, context.expectedType);
+        CompileTimeConstant<?> value = ConstantExpressionEvaluator.evaluate(expression, context.trace, context.expectedType);
 
         if (!(value instanceof IntegerValueTypeConstant)) {
             CompileTimeConstantChecker compileTimeConstantChecker = context.getCompileTimeConstantChecker();
@@ -747,7 +747,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             result = returnType;
         }
 
-        CompileTimeConstant<?> value = ConstantExpressionEvaluator.OBJECT$.evaluate(expression, contextWithExpectedType.trace,
+        CompileTimeConstant<?> value = ConstantExpressionEvaluator.evaluate(expression, contextWithExpectedType.trace,
                                                                                     contextWithExpectedType.expectedType);
         if (value != null) {
             return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType);
@@ -923,8 +923,9 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
             context.trace.report(UNSUPPORTED.on(operationSign, "Unknown operation"));
             result = JetTypeInfo.create(null, context.dataFlowInfo);
         }
-        CompileTimeConstant<?> value = ConstantExpressionEvaluator.OBJECT$.
-                evaluate(expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType);
+        CompileTimeConstant<?> value = ConstantExpressionEvaluator.evaluate(
+                expression, contextWithExpectedType.trace, contextWithExpectedType.expectedType
+        );
         if (value != null) {
             return createCompileTimeConstantTypeInfo(value, expression, contextWithExpectedType);
         }
@@ -1267,7 +1268,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                 }
             });
         }
-        ConstantExpressionEvaluator.OBJECT$.evaluate(expression, context.trace, contextWithExpectedType.expectedType);
+        ConstantExpressionEvaluator.evaluate(expression, context.trace, contextWithExpectedType.expectedType);
         return DataFlowUtils.checkType(components.builtIns.getStringType(), expression, contextWithExpectedType, dataFlowInfo[0]);
     }
 

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowUtils.java

@@ -182,7 +182,7 @@ public class DataFlowUtils {
         }
 
         if (expression instanceof JetConstantExpression) {
-            CompileTimeConstant<?> value = ConstantExpressionEvaluator.OBJECT$.evaluate(expression, c.trace, c.expectedType);
+            CompileTimeConstant<?> value = ConstantExpressionEvaluator.evaluate(expression, c.trace, c.expectedType);
             if (value instanceof IntegerValueTypeConstant) {
                 value = EvaluatePackage.createCompileTimeConstantWithType((IntegerValueTypeConstant) value, c.expectedType);
             }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java

@@ -392,7 +392,7 @@ public class ExpressionTypingServices {
             if (defaultValue != null) {
                 getType(declaringScope, defaultValue, valueParameterDescriptor.getType(), dataFlowInfo, trace);
                 if (DescriptorUtils.isAnnotationClass(DescriptorResolver.getContainingClass(declaringScope))) {
-                    ConstantExpressionEvaluator.OBJECT$.evaluate(defaultValue, trace, valueParameterDescriptor.getType());
+                    ConstantExpressionEvaluator.evaluate(defaultValue, trace, valueParameterDescriptor.getType());
                 }
             }
         }

compiler/light-classes/src/org/jetbrains/kotlin/asJava/KotlinLightClassForPackage.kt

@@ -214,7 +214,7 @@ public class KotlinLightClassForPackage private(
         }
     }
 
-    class object {
+    class object Factory {
         public fun create(
                 manager: PsiManager,
                 qualifiedName: FqName,