From 7c0780455a2b812dddf9a6c9ff35e5a4086d5f0f Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Mon, 14 Sep 2015 19:57:02 +0300 Subject: [PATCH] Remove unused parameter of JetTypeMapper#mapOwner, simplify lots of code --- .../DefaultParameterValueSubstitutor.kt | 60 ++++++++++--------- .../kotlin/codegen/ExpressionCodegen.java | 24 ++++---- .../kotlin/codegen/FunctionCodegen.java | 16 ++--- .../codegen/ImplementationBodyCodegen.java | 10 ++-- .../kotlin/codegen/PlatformStaticGenerator.kt | 3 +- .../kotlin/codegen/TraitImplBodyCodegen.kt | 2 +- .../kotlin/codegen/inline/InlineCodegen.java | 6 +- .../codegen/intrinsics/IntrinsicMethod.java | 4 +- .../kotlin/codegen/state/GenerationState.kt | 16 ++--- .../kotlin/codegen/state/JetTypeMapper.java | 30 ++++------ .../state/JetTypeMapperWithOutDirectory.java | 48 --------------- .../idea/debugger/JetPositionManager.kt | 4 +- 12 files changed, 86 insertions(+), 137 deletions(-) delete mode 100644 compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapperWithOutDirectory.java diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt index f9f0150224f..1f8c079a177 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.codegen import org.jetbrains.kotlin.codegen.binding.CodegenBinding -import org.jetbrains.kotlin.codegen.context.CodegenContext import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.psi.JetClass @@ -25,8 +24,8 @@ import org.jetbrains.kotlin.psi.JetClassOrObject import org.jetbrains.kotlin.psi.JetElement import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue import org.jetbrains.kotlin.resolve.jvm.AsmTypes -import org.jetbrains.kotlin.resolve.jvm.diagnostics.OtherOrigin import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmOverloadsAnnotation +import org.jetbrains.kotlin.resolve.jvm.diagnostics.OtherOrigin import org.jetbrains.org.objectweb.asm.Opcodes import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter @@ -39,12 +38,13 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) { * If all of the parameters of the specified constructor declare default values, * generates a no-argument constructor that passes default values for all arguments. */ - fun generateConstructorOverloadsIfNeeded(constructorDescriptor: ConstructorDescriptor, - classBuilder: ClassBuilder, - context: CodegenContext<*>, - classOrObject: JetClassOrObject) { - if (generateOverloadsIfNeeded(classOrObject, constructorDescriptor, constructorDescriptor, - context, classBuilder)) { + fun generateConstructorOverloadsIfNeeded( + constructorDescriptor: ConstructorDescriptor, + classBuilder: ClassBuilder, + contextKind: OwnerKind, + classOrObject: JetClassOrObject + ) { + if (generateOverloadsIfNeeded(classOrObject, constructorDescriptor, constructorDescriptor, contextKind, classBuilder)) { return } @@ -52,8 +52,7 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) { return } - generateOverloadWithSubstitutedParameters(constructorDescriptor, constructorDescriptor, classBuilder, classOrObject, - context, + generateOverloadWithSubstitutedParameters(constructorDescriptor, constructorDescriptor, classBuilder, classOrObject, contextKind, constructorDescriptor.countDefaultParameters()) } @@ -70,21 +69,25 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) { * implementation in the companion object class) * @return true if the overloads annotation was found on the element, false otherwise */ - fun generateOverloadsIfNeeded(methodElement: JetElement?, - functionDescriptor: FunctionDescriptor, - delegateFunctionDescriptor: FunctionDescriptor, - owner: CodegenContext<*>, - classBuilder: ClassBuilder): Boolean { + fun generateOverloadsIfNeeded( + methodElement: JetElement?, + functionDescriptor: FunctionDescriptor, + delegateFunctionDescriptor: FunctionDescriptor, + contextKind: OwnerKind, + classBuilder: ClassBuilder + ): Boolean { if (!functionDescriptor.hasJvmOverloadsAnnotation()) { return false } val count = functionDescriptor.countDefaultParameters() - val context = owner.intoFunction(functionDescriptor) for (i in 1..count) { - generateOverloadWithSubstitutedParameters(functionDescriptor, delegateFunctionDescriptor, classBuilder, methodElement, context, i) + generateOverloadWithSubstitutedParameters( + functionDescriptor, delegateFunctionDescriptor, classBuilder, methodElement, contextKind, i + ) } + return true } @@ -102,18 +105,19 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) { * implementation in the companion object class) * @param methodElement the PSI element for the method implementation (used in diagnostic messages only) */ - fun generateOverloadWithSubstitutedParameters(functionDescriptor: FunctionDescriptor, - delegateFunctionDescriptor: FunctionDescriptor, - classBuilder: ClassBuilder, - methodElement: JetElement?, - context: CodegenContext<*>, - substituteCount: Int) { + private fun generateOverloadWithSubstitutedParameters( + functionDescriptor: FunctionDescriptor, + delegateFunctionDescriptor: FunctionDescriptor, + classBuilder: ClassBuilder, + methodElement: JetElement?, + contextKind: OwnerKind, + substituteCount: Int + ) { val typeMapper = state.typeMapper - - val isStatic = AsmUtil.isStaticMethod(context.getContextKind(), functionDescriptor) + val isStatic = AsmUtil.isStaticMethod(contextKind, functionDescriptor) val flags = AsmUtil.getVisibilityAccessFlag(functionDescriptor) or (if (isStatic) Opcodes.ACC_STATIC else 0) val remainingParameters = getRemainingParameters(functionDescriptor.getOriginal(), substituteCount) - val signature = typeMapper.mapSignature(functionDescriptor, context.getContextKind(), remainingParameters) + val signature = typeMapper.mapSignature(functionDescriptor, contextKind, remainingParameters) val mv = classBuilder.newMethod(OtherOrigin(methodElement, functionDescriptor), flags, signature.getAsmMethod().getName(), signature.getAsmMethod().getDescriptor(), @@ -136,7 +140,7 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) { val v = InstructionAdapter(mv) mv.visitCode() - val methodOwner = typeMapper.mapToCallableMethod(delegateFunctionDescriptor, false, context).owner + val methodOwner = typeMapper.mapToCallableMethod(delegateFunctionDescriptor, false).owner if (!isStatic) { val thisIndex = frameMap.enterTemp(AsmTypes.OBJECT_TYPE) v.load(thisIndex, methodOwner) // Load this on stack @@ -187,7 +191,7 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) { v.aconst(null) } - val defaultMethod = typeMapper.mapDefaultMethod(delegateFunctionDescriptor, context.getContextKind(), context) + val defaultMethod = typeMapper.mapDefaultMethod(delegateFunctionDescriptor, contextKind) if (functionDescriptor is ConstructorDescriptor) { v.invokespecial(methodOwner.getInternalName(), defaultMethod.getName(), defaultMethod.getDescriptor(), false) } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index 177ca2cac54..2be9032ebdd 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -2210,22 +2210,21 @@ public class ExpressionCodegen extends JetVisitor implem PropertyGetterDescriptor getter = propertyDescriptor.getGetter(); if (getter != null) { - callableGetter = typeMapper.mapToCallableMethod(getter, isSuper, context); + callableGetter = typeMapper.mapToCallableMethod(getter, isSuper); } } if (propertyDescriptor.isVar()) { PropertySetterDescriptor setter = propertyDescriptor.getSetter(); if (setter != null && !couldUseDirectAccessToProperty(propertyDescriptor, false, isDelegatedProperty, context)) { - callableSetter = typeMapper.mapToCallableMethod(setter, isSuper, context); + callableSetter = typeMapper.mapToCallableMethod(setter, isSuper); } } } propertyDescriptor = DescriptorUtils.unwrapFakeOverride(propertyDescriptor); Type backingFieldOwner = - typeMapper.mapOwner(changeOwnerOnTypeMapping ? propertyDescriptor.getContainingDeclaration() : propertyDescriptor, - isCallInsideSameModuleAsDeclared(propertyDescriptor, context, state.getOutDirectory())); + typeMapper.mapOwner(changeOwnerOnTypeMapping ? propertyDescriptor.getContainingDeclaration() : propertyDescriptor); String fieldName; if (isExtensionProperty && !isDelegatedProperty) { @@ -2247,11 +2246,14 @@ public class ExpressionCodegen extends JetVisitor implem } @NotNull - private StackValue.Property intermediateValueForSyntheticExtensionProperty(@NotNull SyntheticJavaPropertyDescriptor propertyDescriptor, StackValue receiver) { + private StackValue.Property intermediateValueForSyntheticExtensionProperty( + @NotNull SyntheticJavaPropertyDescriptor propertyDescriptor, + StackValue receiver + ) { Type type = typeMapper.mapType(propertyDescriptor.getOriginal().getType()); - CallableMethod callableGetter = typeMapper.mapToCallableMethod(propertyDescriptor.getGetMethod(), false, context); + CallableMethod callableGetter = typeMapper.mapToCallableMethod(propertyDescriptor.getGetMethod(), false); FunctionDescriptor setMethod = propertyDescriptor.getSetMethod(); - CallableMethod callableSetter = setMethod != null ? typeMapper.mapToCallableMethod(setMethod, false, context) : null; + CallableMethod callableSetter = setMethod != null ? typeMapper.mapToCallableMethod(setMethod, false) : null; return StackValue.property(propertyDescriptor, null, type, false, null, callableGetter, callableSetter, state, receiver); } @@ -2393,12 +2395,12 @@ public class ExpressionCodegen extends JetVisitor implem return intrinsic.toCallable(fd, superCall, resolvedCall, this); } - return resolveToCallableMethod(fd, superCall, context); + return resolveToCallableMethod(fd, superCall); } @NotNull - private CallableMethod resolveToCallableMethod(@NotNull FunctionDescriptor fd, boolean superCall, @NotNull CodegenContext context) { - return typeMapper.mapToCallableMethod(SamCodegenUtil.resolveSamAdapter(fd), superCall, context); + private CallableMethod resolveToCallableMethod(@NotNull FunctionDescriptor fd, boolean superCall) { + return typeMapper.mapToCallableMethod(SamCodegenUtil.resolveSamAdapter(fd), superCall); } public void invokeMethodWithArguments( @@ -3483,7 +3485,7 @@ public class ExpressionCodegen extends JetVisitor implem boolean isGetter = "get".equals(operationDescriptor.getName().asString()); Callable callable = resolveToCallable(operationDescriptor, false, isGetter ? resolvedGetCall : resolvedSetCall); - Callable callableMethod = resolveToCallableMethod(operationDescriptor, false, context); + Callable callableMethod = resolveToCallableMethod(operationDescriptor, false); Type[] argumentTypes = callableMethod.getParameterTypes(); StackValue collectionElementReceiver = createCollectionElementReceiver( diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index 33d323753b9..43c94286739 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -27,7 +27,10 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.backend.common.bridges.Bridge; import org.jetbrains.kotlin.backend.common.bridges.BridgesPackage; import org.jetbrains.kotlin.codegen.annotation.AnnotatedWithOnlyTargetedAnnotations; -import org.jetbrains.kotlin.codegen.context.*; +import org.jetbrains.kotlin.codegen.context.CodegenContext; +import org.jetbrains.kotlin.codegen.context.CodegenContextUtil; +import org.jetbrains.kotlin.codegen.context.DelegatingFacadeContext; +import org.jetbrains.kotlin.codegen.context.MethodContext; import org.jetbrains.kotlin.codegen.optimization.OptimizationMethodVisitor; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; @@ -121,10 +124,9 @@ public class FunctionCodegen { @NotNull FunctionDescriptor functionDescriptor, @NotNull FunctionDescriptor delegateFunctionDescriptor ) { - new DefaultParameterValueSubstitutor(state).generateOverloadsIfNeeded(function, - functionDescriptor, - delegateFunctionDescriptor, - owner, v); + new DefaultParameterValueSubstitutor(state).generateOverloadsIfNeeded( + function, functionDescriptor, delegateFunctionDescriptor, owner.getContextKind(), v + ); } public void generateMethod( @@ -580,7 +582,7 @@ public class FunctionCodegen { // $default methods are never private to be accessible from other class files (e.g. inner) without the need of synthetic accessors flags &= ~ACC_PRIVATE; - Method defaultMethod = typeMapper.mapDefaultMethod(functionDescriptor, kind, owner); + Method defaultMethod = typeMapper.mapDefaultMethod(functionDescriptor, kind); MethodVisitor mv = v.newMethod( Synthetic(function, functionDescriptor), @@ -667,7 +669,7 @@ public class FunctionCodegen { method = state.getTypeMapper().mapToCallableMethod((ConstructorDescriptor) functionDescriptor); } else { - method = state.getTypeMapper().mapToCallableMethod(functionDescriptor, false, methodContext); + method = state.getTypeMapper().mapToCallableMethod(functionDescriptor, false); } generator.genCallWithoutAssertions(method, codegen); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index 16d6b75203a..dbd04bd4121 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -944,7 +944,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { ((AccessorForCallableDescriptor) accessorDescriptor).getSuperCallExpression() != null; CallableMethod callableMethod = isConstructor ? typeMapper.mapToCallableMethod((ConstructorDescriptor) functionDescriptor) : - typeMapper.mapToCallableMethod(functionDescriptor, superCall, context); + typeMapper.mapToCallableMethod(functionDescriptor, superCall); int reg = 1; if (isConstructor && !accessorIsConstructor) { @@ -1084,8 +1084,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { functionCodegen.generateDefaultIfNeeded(constructorContext, constructorDescriptor, OwnerKind.IMPLEMENTATION, DefaultParameterValueLoader.DEFAULT, null); - new DefaultParameterValueSubstitutor(state).generateConstructorOverloadsIfNeeded(constructorDescriptor, v, - constructorContext, myClass); + new DefaultParameterValueSubstitutor(state).generateConstructorOverloadsIfNeeded(constructorDescriptor, v, kind, myClass); if (isCompanionObject(descriptor)) { context.recordSyntheticAccessorIfNeeded(constructorDescriptor, bindingContext); @@ -1110,8 +1109,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { functionCodegen.generateDefaultIfNeeded(constructorContext, constructorDescriptor, OwnerKind.IMPLEMENTATION, DefaultParameterValueLoader.DEFAULT, null); - new DefaultParameterValueSubstitutor(state).generateOverloadsIfNeeded(myClass, constructorDescriptor, constructorDescriptor, - constructorContext, v); + new DefaultParameterValueSubstitutor(state).generateOverloadsIfNeeded( + myClass, constructorDescriptor, constructorDescriptor, kind, v + ); } private void generatePrimaryConstructorImpl( diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PlatformStaticGenerator.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/PlatformStaticGenerator.kt index 245b3708157..61143220ea2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PlatformStaticGenerator.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PlatformStaticGenerator.kt @@ -65,8 +65,7 @@ class PlatformStaticGenerator( val syntheticOrOriginalMethod = typeMapper.mapToCallableMethod( codegen.getContext().accessibleDescriptor(descriptor, /* superCallExpression = */ null), - false, - codegen.getContext() + false ) syntheticOrOriginalMethod.genInvokeInstruction(iv) iv.areturn(asmMethod.returnType) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/TraitImplBodyCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/TraitImplBodyCodegen.kt index d0643330c8f..4f3f12cd5b5 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/TraitImplBodyCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/TraitImplBodyCodegen.kt @@ -101,7 +101,7 @@ public class TraitImplBodyCodegen( override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) { val iv = codegen.v - val method = typeMapper.mapToCallableMethod(delegateTo, true, context) + val method = typeMapper.mapToCallableMethod(delegateTo, true) val myParameters = signature.getValueParameters() val calleeParameters = method.getValueParameters() diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java index 34d8341d3bc..499fe5811a3 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java @@ -185,7 +185,7 @@ public class InlineCodegen extends CallGenerator { Method asmMethod; if (callDefault) { - asmMethod = typeMapper.mapDefaultMethod(functionDescriptor, context.getContextKind(), context); + asmMethod = typeMapper.mapDefaultMethod(functionDescriptor, context.getContextKind()); } else { asmMethod = jvmSignature.getAsmMethod(); @@ -231,7 +231,7 @@ public class InlineCodegen extends CallGenerator { SMAP smap; if (callDefault) { - Type ownerType = typeMapper.mapOwner(functionDescriptor, true/*TODO: false, migration*/); + Type ownerType = typeMapper.mapOwner(functionDescriptor); FakeMemberCodegen parentCodegen = new FakeMemberCodegen(codegen.getParentCodegen(), inliningFunction, (FieldOwnerContext) methodContext.getParentContext(), ownerType.getInternalName()); @@ -343,7 +343,7 @@ public class InlineCodegen extends CallGenerator { new FakeMemberCodegen(codegen.getParentCodegen(), expression, (FieldOwnerContext) context.getParentContext(), isLambda ? codegen.getParentCodegen().getClassName() - : typeMapper.mapOwner(descriptor, true /*TODO: false, migration*/).getInternalName()); + : typeMapper.mapOwner(descriptor).getInternalName()); FunctionGenerationStrategy strategy = expression instanceof JetCallableReferenceExpression ? diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethod.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethod.java index eb37cd40ffc..ad37de4e419 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethod.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethod.java @@ -33,7 +33,7 @@ public abstract class IntrinsicMethod { @NotNull ResolvedCall resolvedCall, @NotNull ExpressionCodegen codegen ) { - return toCallable(codegen.getState().getTypeMapper().mapToCallableMethod(fd, false, codegen.getContext()), isSuper, resolvedCall); + return toCallable(codegen.getState().getTypeMapper().mapToCallableMethod(fd, false), isSuper, resolvedCall); } @NotNull @@ -58,4 +58,4 @@ public abstract class IntrinsicMethod { public Type nullOr(Type type, Type newType) { return type == null ? null : newType; } -} \ No newline at end of file +} diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt index c71438e4878..c53a2eff481 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt @@ -29,7 +29,6 @@ import org.jetbrains.kotlin.codegen.optimization.OptimizationClassBuilderFactory import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.ScriptDescriptor import org.jetbrains.kotlin.diagnostics.DiagnosticSink -import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.name.FqName @@ -41,7 +40,7 @@ import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.DelegatingBindingTrace import java.io.File -public class GenerationState jvmOverloads constructor( +public class GenerationState @JvmOverloads constructor( public val project: Project, builderFactory: ClassBuilderFactory, public val module: ModuleDescriptor, @@ -58,7 +57,9 @@ public class GenerationState jvmOverloads constructor( // for PackageCodegen in incremental compilation mode public val targetId: TargetId? = null, moduleName: String? = null, - // TODO: temporary hack, see JetTypeMapperWithOutDirectory state for details + // 'outDirectory' is a hack to correctly determine if a compiled class is from the same module as the callee during + // partial compilation. Module chunks are treated as a single module. + // TODO: get rid of it with the proper module infrastructure public val outDirectory: File? = null, public val incrementalCompilationComponents: IncrementalCompilationComponents? = null, public val progress: Progress = Progress.DEAF @@ -87,8 +88,7 @@ public class GenerationState jvmOverloads constructor( public val classBuilderMode: ClassBuilderMode = builderFactory.getClassBuilderMode() public val bindingTrace: BindingTrace = DelegatingBindingTrace(bindingContext, "trace in GenerationState") public val bindingContext: BindingContext = bindingTrace.getBindingContext() - public val typeMapper: JetTypeMapper = - JetTypeMapperWithOutDirectory(this.bindingContext, classBuilderMode, fileClassesProvider, outDirectory) + public val typeMapper: JetTypeMapper = JetTypeMapper(this.bindingContext, classBuilderMode, fileClassesProvider) public val intrinsics: IntrinsicMethods = IntrinsicMethods() public val samWrapperClasses: SamWrapperClasses = SamWrapperClasses(this) public val inlineCycleReporter: InlineCycleReporter = InlineCycleReporter(diagnostics) @@ -101,13 +101,13 @@ public class GenerationState jvmOverloads constructor( private var used = false public val isCallAssertionsEnabled: Boolean = !disableCallAssertions - @jvmName("isCallAssertionsEnabled") get + @JvmName("isCallAssertionsEnabled") get public val isParamAssertionsEnabled: Boolean = !disableParamAssertions - @jvmName("isParamAssertionsEnabled") get + @JvmName("isParamAssertionsEnabled") get public val isInlineEnabled: Boolean = !disableInline - @jvmName("isInlineEnabled") get + @JvmName("isInlineEnabled") get public val moduleName: String = moduleName ?: JvmCodegenUtil.getModuleName(module) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java index 05e3b32695d..dc57b4ac65d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java @@ -28,7 +28,6 @@ import org.jetbrains.kotlin.codegen.*; import org.jetbrains.kotlin.codegen.binding.CodegenBinding; import org.jetbrains.kotlin.codegen.binding.MutableClosure; import org.jetbrains.kotlin.codegen.binding.PsiCodegenPredictor; -import org.jetbrains.kotlin.codegen.context.CodegenContext; import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.fileClasses.FileClassesPackage; @@ -69,7 +68,6 @@ import org.jetbrains.kotlin.types.expressions.OperatorConventions; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.commons.Method; -import java.io.File; import java.util.ArrayList; import java.util.List; @@ -139,7 +137,7 @@ public class JetTypeMapper { } @NotNull - public Type mapOwner(@NotNull DeclarationDescriptor descriptor, boolean isInsideModule) { + public Type mapOwner(@NotNull DeclarationDescriptor descriptor) { if (isLocalFunction(descriptor)) { return asmTypeForAnonymousClass(bindingContext, (FunctionDescriptor) descriptor); } @@ -594,11 +592,7 @@ public class JetTypeMapper { } @NotNull - public CallableMethod mapToCallableMethod( - @NotNull FunctionDescriptor descriptor, - boolean superCall, - @NotNull CodegenContext context - ) { + public CallableMethod mapToCallableMethod(@NotNull FunctionDescriptor descriptor, boolean superCall) { DeclarationDescriptor functionParent = descriptor.getOriginal().getContainingDeclaration(); FunctionDescriptor functionDescriptor = unwrapFakeOverride(descriptor.getOriginal()); @@ -663,7 +657,7 @@ public class JetTypeMapper { } else { signature = mapSignature(functionDescriptor.getOriginal()); - owner = mapOwner(functionDescriptor, isCallInsideSameModuleAsDeclared(functionDescriptor, context, getOutDirectory())); + owner = mapOwner(functionDescriptor); ownerForDefaultParam = owner; ownerForDefaultImpl = owner; if (functionParent instanceof PackageFragmentDescriptor) { @@ -852,13 +846,15 @@ public class JetTypeMapper { } @NotNull - public Method mapDefaultMethod(@NotNull FunctionDescriptor functionDescriptor, @NotNull OwnerKind kind, @NotNull CodegenContext context) { + public Method mapDefaultMethod(@NotNull FunctionDescriptor functionDescriptor, @NotNull OwnerKind kind) { Method jvmSignature = mapSignature(functionDescriptor, kind).getAsmMethod(); - Type ownerType = mapOwner(functionDescriptor, isCallInsideSameModuleAsDeclared(functionDescriptor, context, getOutDirectory())); + Type ownerType = mapOwner(functionDescriptor); boolean isConstructor = isConstructor(jvmSignature); - String descriptor = getDefaultDescriptor(jvmSignature, - isStaticMethod(kind, functionDescriptor) || isConstructor ? null : ownerType.getDescriptor(), - functionDescriptor.getExtensionReceiverParameter() != null); + String descriptor = getDefaultDescriptor( + jvmSignature, + isStaticMethod(kind, functionDescriptor) || isConstructor ? null : ownerType.getDescriptor(), + functionDescriptor.getExtensionReceiverParameter() != null + ); return new Method(isConstructor ? "" : jvmSignature.getName() + JvmAbi.DEFAULT_PARAMS_IMPL_SUFFIX, descriptor); } @@ -1142,10 +1138,4 @@ public class JetTypeMapper { } return null; } - - // TODO Temporary hack until modules infrastructure is implemented. See JetTypeMapperWithOutDirectory for details - @Nullable - protected File getOutDirectory() { - return null; - } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapperWithOutDirectory.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapperWithOutDirectory.java deleted file mode 100644 index 4b2cf4a9586..00000000000 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapperWithOutDirectory.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.codegen.state; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.codegen.ClassBuilderMode; -import org.jetbrains.kotlin.fileClasses.JvmFileClassesProvider; -import org.jetbrains.kotlin.resolve.BindingContext; - -import java.io.File; - -// TODO Temporary hack until modules infrastructure is implemented. -// This class is necessary for detecting if compiled class is from the same module as callee. -// Module chunks are treated as single module. -public class JetTypeMapperWithOutDirectory extends JetTypeMapper { - private final File outDirectory; - - public JetTypeMapperWithOutDirectory( - @NotNull BindingContext bindingContext, - @NotNull ClassBuilderMode classBuilderMode, - @NotNull JvmFileClassesProvider fileClassesManager, - @Nullable File outDirectory - ) { - super(bindingContext, classBuilderMode, fileClassesManager); - this.outDirectory = outDirectory; - } - - @Nullable - @Override - public File getOutDirectory() { - return outDirectory; - } -} diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt index c0ca4bb4af8..b0cb4a50ace 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt +++ b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt @@ -408,8 +408,8 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Mult public fun getJvmInternalNameForPropertyOwner(typeMapper: JetTypeMapper, descriptor: PropertyDescriptor): String { return typeMapper.mapOwner( - if (AsmUtil.isPropertyWithBackingFieldInOuterClass(descriptor)) descriptor.getContainingDeclaration() else descriptor, - true).getInternalName() + if (AsmUtil.isPropertyWithBackingFieldInOuterClass(descriptor)) descriptor.containingDeclaration else descriptor + ).internalName } private fun isInPropertyAccessor(element: PsiElement?) =