From 34d14939f944a6a39da7167dc22aec19debe352f Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 1 Oct 2015 01:54:36 +0300 Subject: [PATCH] Fix build after change in property accessor names --- .../kotlin/codegen/ExpressionCodegen.java | 7 +++++-- .../inline/InternalFinallyBlockInliner.java | 2 +- .../kotlin/cli/jvm/repl/ReplInterpreter.java | 14 ++++++++++---- .../kotlin/cfg/JetFlowInformationProvider.java | 2 +- .../kotlin/cfg/TailRecursionDetector.java | 2 +- .../kotlin/cfg/pseudocode/PseudocodeUtil.java | 11 ++++++++--- .../org/jetbrains/kotlin/resolve/BodyResolver.java | 9 ++++++--- .../kotlin/resolve/ControlFlowAnalyzer.java | 4 ++-- .../resolve/calls/CallExpressionResolver.java | 2 +- .../resolve/calls/checkers/InlineChecker.java | 6 +++--- .../kotlin/DeserializedDescriptorResolver.java | 2 +- .../JetChangeSignatureUsageProcessor.java | 4 ++-- .../JetPrimaryConstructorParameterTableModel.java | 2 +- .../usages/JetCallableDefinitionUsage.java | 2 +- .../src/org/jetbrains/kotlin/js/config/Config.java | 5 +++-- .../kotlin/js/config/LibrarySourcesConfig.java | 6 ++++-- .../translate/expression/FunctionTranslator.java | 5 ++--- .../kotlin/js/translate/utils/ManglingUtils.java | 10 ++++------ 18 files changed, 56 insertions(+), 39 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 33c5eaef130..c64ac3368e4 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -59,7 +59,10 @@ import org.jetbrains.kotlin.load.java.descriptors.SamConstructorDescriptor; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.renderer.DescriptorRenderer; -import org.jetbrains.kotlin.resolve.*; +import org.jetbrains.kotlin.resolve.BindingContext; +import org.jetbrains.kotlin.resolve.BindingContextUtils; +import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; +import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage; import org.jetbrains.kotlin.resolve.calls.callResolverUtil.CallResolverUtilPackage; import org.jetbrains.kotlin.resolve.calls.model.*; @@ -2758,7 +2761,7 @@ public class ExpressionCodegen extends JetVisitor implem JetType type = bindingContext.getType(expression); assert type != null; - assert state.getReflectionTypes().getkClass().getTypeConstructor().equals(type.getConstructor()) + assert state.getReflectionTypes().getKClass().getTypeConstructor().equals(type.getConstructor()) : "::class expression should be type checked to a KClass: " + type; return generateClassLiteralReference(typeMapper, KotlinPackage.single(type.getArguments()).getType()); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java index f57d10f40e9..f45c128ebd3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java @@ -522,7 +522,7 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor { @Nullable private static AbstractInsnNode getNextMeaningful(@NotNull AbstractInsnNode node) { AbstractInsnNode result = node.getNext(); - while (result != null && !CommonPackage.getIsMeaningful(result)) { + while (result != null && !CommonPackage.isMeaningful(result)) { result = result.getNext(); } return result; diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java index 86c5ef18814..7e1fa23f730 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java @@ -36,10 +36,14 @@ import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport; import org.jetbrains.kotlin.cli.common.messages.DiagnosticMessageReporter; import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; +import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.cli.jvm.repl.di.ContainerForReplWithJava; import org.jetbrains.kotlin.cli.jvm.repl.di.DiPackage; -import org.jetbrains.kotlin.cli.jvm.repl.messages.*; +import org.jetbrains.kotlin.cli.jvm.repl.messages.DiagnosticMessageHolder; +import org.jetbrains.kotlin.cli.jvm.repl.messages.ReplIdeDiagnosticMessageHolder; +import org.jetbrains.kotlin.cli.jvm.repl.messages.ReplSystemInWrapper; +import org.jetbrains.kotlin.cli.jvm.repl.messages.ReplTerminalDiagnosticMessageHolder; import org.jetbrains.kotlin.codegen.ClassBuilderFactories; import org.jetbrains.kotlin.codegen.CompilationErrorHandler; import org.jetbrains.kotlin.codegen.KotlinCodegenFacade; @@ -59,7 +63,6 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.jvm.JvmClassName; import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM; import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider; -import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider; import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo; import org.jetbrains.kotlin.resolve.lazy.declarations.*; @@ -75,7 +78,10 @@ import java.lang.reflect.Field; import java.net.MalformedURLException; import java.net.URL; import java.net.URLClassLoader; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getJvmClasspathRoots; import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getModuleName; @@ -363,7 +369,7 @@ public class ReplInterpreter { private void setReplScriptExecuting(boolean isExecuting) { if (replReader != null) { - replReader.setIsReplScriptExecuting(isExecuting); + replReader.setReplScriptExecuting(isExecuting); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java index 61f18d77b46..b2407fa2bbf 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java @@ -336,7 +336,7 @@ public class JetFlowInformationProvider { } if (!(instruction instanceof WriteValueInstruction)) return; WriteValueInstruction writeValueInstruction = (WriteValueInstruction) instruction; - JetElement element = writeValueInstruction.getlValue(); + JetElement element = writeValueInstruction.getLValue(); boolean error = checkBackingField(ctxt, element); if (!(element instanceof JetExpression)) return; if (!error) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/TailRecursionDetector.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/TailRecursionDetector.java index bb4330ed666..60dd84faf4f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/TailRecursionDetector.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/TailRecursionDetector.java @@ -50,7 +50,7 @@ public class TailRecursionDetector extends InstructionVisitorWithResult @Override public Boolean visitSubroutineExit(@NotNull SubroutineExitInstruction instruction) { - return !instruction.getIsError() && instruction.getSubroutine() == subroutine; + return !instruction.isError() && instruction.getSubroutine() == subroutine; } @Override diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeUtil.java index 31360d9cd6c..c238202ae0a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeUtil.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/PseudocodeUtil.java @@ -20,11 +20,16 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.cfg.JetControlFlowProcessor; import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction; -import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.*; +import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.AccessTarget; +import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.AccessValueInstruction; +import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.ReadValueInstruction; +import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.WriteValueInstruction; import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.VariableDeclarationInstruction; import org.jetbrains.kotlin.descriptors.VariableDescriptor; import org.jetbrains.kotlin.diagnostics.Diagnostic; -import org.jetbrains.kotlin.psi.*; +import org.jetbrains.kotlin.psi.JetDeclaration; +import org.jetbrains.kotlin.psi.JetElement; +import org.jetbrains.kotlin.psi.JetExpression; import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.BindingContextUtils; import org.jetbrains.kotlin.resolve.BindingTrace; @@ -89,7 +94,7 @@ public class PseudocodeUtil { element = ((ReadValueInstruction) instruction).getElement(); } else if (instruction instanceof WriteValueInstruction) { - element = ((WriteValueInstruction) instruction).getlValue(); + element = ((WriteValueInstruction) instruction).getLValue(); } else if (instruction instanceof VariableDeclarationInstruction) { element = ((VariableDeclarationInstruction) instruction).getVariableDeclarationElement(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index de4be006fa7..3c1a9662abc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java @@ -37,7 +37,10 @@ import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.resolve.calls.util.CallMaker; import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil; -import org.jetbrains.kotlin.resolve.scopes.*; +import org.jetbrains.kotlin.resolve.scopes.JetScopeUtils; +import org.jetbrains.kotlin.resolve.scopes.LexicalScope; +import org.jetbrains.kotlin.resolve.scopes.LexicalScopeImpl; +import org.jetbrains.kotlin.resolve.scopes.RedeclarationHandler; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.kotlin.types.*; import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext; @@ -110,7 +113,7 @@ public class BodyResolver { // SCRIPT: resolve script bodies scriptBodyResolverResolver.resolveScriptBodies(c); - if (!c.getTopDownAnalysisMode().getIsLocalDeclarations()) { + if (!c.getTopDownAnalysisMode().isLocalDeclarations()) { computeDeferredTypes(); } } @@ -732,7 +735,7 @@ public class BodyResolver { LexicalScope scope = c.getDeclaringScope(declaration); assert scope != null : "Scope is null: " + PsiUtilPackage.getElementTextWithContext(declaration); - if (!c.getTopDownAnalysisMode().getIsLocalDeclarations() && !(bodyResolveCache instanceof BodyResolveCache.ThrowException) && + if (!c.getTopDownAnalysisMode().isLocalDeclarations() && !(bodyResolveCache instanceof BodyResolveCache.ThrowException) && expressionTypingServices.getStatementFilter() != StatementFilter.NONE) { bodyResolveCache.resolveFunctionBody(declaration).addOwnDataTo(trace, true); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java index d860f723095..c9575d8d404 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ControlFlowAnalyzer.java @@ -74,7 +74,7 @@ public class ControlFlowAnalyzer { // A pseudocode of class/object initialization corresponds to a class/object // or initialization of properties corresponds to a package declared in a file JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider((JetElement) declarationContainer, trace); - if (c.getTopDownAnalysisMode().getIsLocalDeclarations()) { + if (c.getTopDownAnalysisMode().isLocalDeclarations()) { flowInformationProvider.checkForLocalClassOrObjectMode(); return; } @@ -95,7 +95,7 @@ public class ControlFlowAnalyzer { private void checkFunction(@NotNull BodiesResolveContext c, @NotNull JetDeclarationWithBody function, @Nullable JetType expectedReturnType) { if (!function.hasBody()) return; JetFlowInformationProvider flowInformationProvider = new JetFlowInformationProvider(function, trace); - if (c.getTopDownAnalysisMode().getIsLocalDeclarations()) { + if (c.getTopDownAnalysisMode().isLocalDeclarations()) { flowInformationProvider.checkForLocalClassOrObjectMode(); return; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java index fb609151c2b..7e5e7b27971 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallExpressionResolver.java @@ -385,7 +385,7 @@ public class CallExpressionResolver { } CompileTimeConstant value = constantExpressionEvaluator.evaluateExpression(expression, context.trace, context.expectedType); - if (value != null && value.getIsPure()) { + if (value != null && value.isPure()) { return dataFlowAnalyzer.createCompileTimeConstantTypeInfo(value, expression, context); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java index c580b49c48c..065189225b9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.java @@ -43,7 +43,7 @@ import java.util.Set; import static org.jetbrains.kotlin.diagnostics.Errors.NON_LOCAL_RETURN_NOT_ALLOWED; import static org.jetbrains.kotlin.diagnostics.Errors.USAGE_IS_NOT_INLINABLE; -import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getIsEffectivelyPublicApi; +import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.isEffectivelyPublicApi; import static org.jetbrains.kotlin.resolve.inline.InlineUtil.allowsNonLocalReturns; import static org.jetbrains.kotlin.resolve.inline.InlineUtil.checkNonLocalReturnUsage; @@ -55,7 +55,7 @@ class InlineChecker implements CallChecker { public InlineChecker(@NotNull SimpleFunctionDescriptor descriptor) { assert InlineUtil.isInline(descriptor) : "This extension should be created only for inline functions: " + descriptor; this.descriptor = descriptor; - this.isEffectivelyPublicApiFunction = getIsEffectivelyPublicApi(descriptor); + this.isEffectivelyPublicApiFunction = isEffectivelyPublicApi(descriptor); for (ValueParameterDescriptor param : descriptor.getValueParameters()) { if (isInlinableParameter(param)) { @@ -236,7 +236,7 @@ class InlineChecker implements CallChecker { } private void checkVisibility(@NotNull CallableDescriptor declarationDescriptor, @NotNull JetElement expression, @NotNull BasicCallResolutionContext context){ - boolean declarationDescriptorIsPublicApi = getIsEffectivelyPublicApi(declarationDescriptor) || isDefinedInInlineFunction(declarationDescriptor); + boolean declarationDescriptorIsPublicApi = isEffectivelyPublicApi(declarationDescriptor) || isDefinedInInlineFunction(declarationDescriptor); if (isEffectivelyPublicApiFunction && !declarationDescriptorIsPublicApi && declarationDescriptor.getVisibility() != Visibilities.LOCAL) { context.trace.report(Errors.INVISIBLE_MEMBER_FROM_INLINE.on(expression, declarationDescriptor, descriptor)); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java index 1dd78a0bfa8..cf5bb240706 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/DeserializedDescriptorResolver.java @@ -112,7 +112,7 @@ public final class DeserializedDescriptorResolver { @Nullable public String[] readData(@NotNull KotlinJvmBinaryClass kotlinClass, @NotNull Set expectedKinds) { KotlinClassHeader header = kotlinClass.getClassHeader(); - if (!header.getIsCompatibleAbiVersion()) { + if (!header.isCompatibleAbiVersion()) { errorReporter.reportIncompatibleAbiVersion(kotlinClass.getClassId(), kotlinClass.getLocation(), header.getVersion()); } else if (expectedKinds.contains(header.getKind())) { diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java index 4a35b5da4b3..be8f0564ec4 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java @@ -619,7 +619,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro JetScope callableScope = org.jetbrains.kotlin.idea.refactoring.RefactoringPackage.getContainingScope(oldDescriptor, bindingContext); JetMethodDescriptor.Kind kind = ChangeSignaturePackage.getKind(changeInfo); - if (!kind.getIsConstructor() && callableScope != null && !info.getNewName().isEmpty()) { + if (!kind.isConstructor() && callableScope != null && !info.getNewName().isEmpty()) { Name newName = Name.identifier(info.getNewName()); Collection conflicts = oldDescriptor instanceof FunctionDescriptor ? ScopeUtils.getAllAccessibleFunctions(callableScope, newName) @@ -703,7 +703,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro } ); for (JetParameterInfo parameterInfo : changeInfo.getNonReceiverParameters()) { - if (!(parameterInfo.getIsNewParameter())) continue; + if (!(parameterInfo.isNewParameter())) continue; String name = parameterInfo.getName(); JetParameter parameter = existingParameters.get(name); diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java index 82553775fe5..e3e42a5fe6a 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetPrimaryConstructorParameterTableModel.java @@ -52,7 +52,7 @@ public class JetPrimaryConstructorParameterTableModel extends JetCallableParamet @Override public boolean isCellEditable(ParameterTableModelItemBase item) { - return !item.isEllipsisType() && item.parameter.getIsNewParameter(); + return !item.isEllipsisType() && item.parameter.isNewParameter(); } @Override diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java index 5912975dd57..e1e1e0d7fa0 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetCallableDefinitionUsage.java @@ -376,7 +376,7 @@ public class JetCallableDefinitionUsage extends JetUsageIn parameter.addBefore(psiFactory.createWhiteSpace(), firstChild); } - if (parameterInfo.getIsTypeChanged() && parameter.getTypeReference() != null) { + if (parameterInfo.isTypeChanged() && parameter.getTypeReference() != null) { String renderedType = parameterInfo.renderType(parameterIndex, this); parameter.setTypeReference(psiFactory.createType(renderedType)); } diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java b/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java index 0e5900abc98..f1898b5cfb5 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/config/Config.java @@ -148,8 +148,9 @@ public abstract class Config { } private ModuleDescriptorImpl createModuleDescriptor(KotlinJavascriptMetadata metadata) { - assert metadata.getIsAbiVersionCompatible() : - "expected abi version " + KotlinJavascriptMetadataUtils.ABI_VERSION + ", but metadata.abiVersion = " + metadata.getAbiVersion(); + assert metadata.isAbiVersionCompatible() : + "expected abi version " + KotlinJavascriptMetadataUtils.ABI_VERSION + + ", but metadata.abiVersion = " + metadata.getAbiVersion(); ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl( Name.special("<" + metadata.getModuleName() + ">"), storageManager, diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java b/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java index 3fb7f12385d..a6aa854e009 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java @@ -168,8 +168,10 @@ public class LibrarySourcesConfig extends Config { } for (KotlinJavascriptMetadata metadata : metadataList) { - if (!metadata.getIsAbiVersionCompatible()) { - report.invoke("File '" + path + "' was compiled with an incompatible version of Kotlin. Its ABI version is " + metadata.getAbiVersion() + ", expected ABI version is " + KotlinJavascriptMetadataUtils.ABI_VERSION); + if (!metadata.isAbiVersionCompatible()) { + report.invoke("File '" + path + "' was compiled with an incompatible version of Kotlin. " + + "Its ABI version is " + metadata.getAbiVersion() + + ", expected ABI version is " + KotlinJavascriptMetadataUtils.ABI_VERSION); return true; } } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/FunctionTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/FunctionTranslator.java index c86ec40ce0c..36119423223 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/FunctionTranslator.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/expression/FunctionTranslator.java @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.js.translate.expression; - import com.google.dart.compiler.backend.js.ast.*; import com.google.dart.compiler.backend.js.ast.metadata.MetadataProperties; import com.intellij.util.SmartList; @@ -42,7 +41,7 @@ import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getFunctionDe import static org.jetbrains.kotlin.js.translate.utils.ErrorReportingUtils.message; import static org.jetbrains.kotlin.js.translate.utils.FunctionBodyTranslator.translateFunctionBody; import static org.jetbrains.kotlin.js.translate.utils.JsAstUtils.setParameters; -import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.getIsEffectivelyPublicApi; +import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage.isEffectivelyPublicApi; public final class FunctionTranslator extends AbstractTranslator { @NotNull @@ -100,7 +99,7 @@ public final class FunctionTranslator extends AbstractTranslator { JsName functionName = context().getNameForDescriptor(descriptor); generateFunctionObject(); - if (shouldBeInlined(descriptor) && getIsEffectivelyPublicApi(descriptor)) { + if (shouldBeInlined(descriptor) && isEffectivelyPublicApi(descriptor)) { InlineMetadata metadata = InlineMetadata.compose(functionObject, descriptor); return new JsPropertyInitializer(functionName.makeRef(), metadata.getFunctionWithMetadata()); } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ManglingUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ManglingUtils.java index f9b40aa00bf..26134cf4a96 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ManglingUtils.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/ManglingUtils.java @@ -82,7 +82,7 @@ public class ManglingUtils { DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); if (containingDeclaration instanceof PackageFragmentDescriptor) { - return descriptor.getVisibility().getIsPublicAPI(); + return descriptor.getVisibility().isPublicAPI(); } else if (containingDeclaration instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; @@ -98,7 +98,7 @@ public class ManglingUtils { } // Don't use stable mangling when it inside a non-public API declaration. - if (!classDescriptor.getVisibility().getIsPublicAPI()) { + if (!classDescriptor.getVisibility().isPublicAPI()) { return false; } @@ -144,9 +144,7 @@ public class ManglingUtils { @NotNull private static String getSuggestedName(@NotNull CallableDescriptor descriptor) { if (descriptor instanceof ConstructorDescriptor && !((ConstructorDescriptor) descriptor).isPrimary()) { - DeclarationDescriptor classDescriptor = descriptor.getContainingDeclaration(); - assert classDescriptor != null; - return classDescriptor.getName().asString(); + return descriptor.getContainingDeclaration().getName().asString(); } else { return descriptor.getName().asString(); @@ -161,7 +159,7 @@ public class ManglingUtils { String nameToCompare = descriptor.getName().asString(); - if (containingDeclaration != null && descriptor instanceof ConstructorDescriptor) { + if (descriptor instanceof ConstructorDescriptor) { nameToCompare = containingDeclaration.getName().asString(); containingDeclaration = containingDeclaration.getContainingDeclaration(); }