diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt index 75db2fba440..76b660fcdc7 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ScriptCodegen.kt @@ -75,9 +75,7 @@ class ScriptCodegen private constructor( val jvmSignature = typeMapper.mapScriptSignature( scriptDescriptor, - scriptContext.earlierScripts, - scriptDefinition.implicitReceivers, - scriptDefinition.environmentVariables + scriptContext.earlierScripts ) if (state.replSpecific.shouldGenerateScriptResultValue) { @@ -104,37 +102,6 @@ class ScriptCodegen private constructor( val superclass = scriptDescriptor.getSuperClassNotAny() // TODO: throw if class is not found) - if (superclass == null) { - iv.load(0, classType) - iv.invokespecial("java/lang/Object", "", "()V", false) - } - else { - val ctorDesc = superclass.unsubstitutedPrimaryConstructor - ?: throw RuntimeException("Primary constructor not found for script template " + superclass.toString()) - - iv.load(0, classType) - - fun Int.incrementIf(cond: Boolean): Int = if (cond) plus(1) else this - val valueParamStart = 1 - .incrementIf(scriptContext.earlierScripts.isNotEmpty()) - .incrementIf(scriptDefinition.implicitReceivers.isNotEmpty()) - .incrementIf(scriptDefinition.environmentVariables.isNotEmpty()) - - val valueParameters = scriptDescriptor.unsubstitutedPrimaryConstructor.valueParameters - for (superclassParam in ctorDesc.valueParameters) { - val valueParam = valueParameters.first { it.name == superclassParam.name } - iv.load(valueParam!!.index + valueParamStart, typeMapper.mapType(valueParam.type)) - } - - val ctorMethod = typeMapper.mapToCallableMethod(ctorDesc, false) - val sig = ctorMethod.getAsmMethod().descriptor - - iv.invokespecial( - typeMapper.mapSupertype(superclass.defaultType, null).internalName, - "", sig, false) - } - iv.load(0, classType) - val frameMap = FrameMap() frameMap.enterTemp(OBJECT_TYPE) @@ -157,6 +124,37 @@ class ScriptCodegen private constructor( } } + if (superclass == null) { + iv.load(0, classType) + iv.invokespecial("java/lang/Object", "", "()V", false) + } else { + val ctorDesc = superclass.unsubstitutedPrimaryConstructor + ?: throw RuntimeException("Primary constructor not found for script template " + superclass.toString()) + + iv.load(0, classType) + + fun Int.incrementIf(cond: Boolean): Int = if (cond) plus(1) else this + val valueParamStart = 1 + .incrementIf(scriptContext.earlierScripts.isNotEmpty()) + + val valueParameters = scriptDescriptor.unsubstitutedPrimaryConstructor.valueParameters + for (superclassParam in ctorDesc.valueParameters) { + val valueParam = valueParameters.first { it.name == superclassParam.name } + val paramType = typeMapper.mapType(valueParam.type) + iv.load(valueParam!!.index + valueParamStart, paramType) + frameMap.enterTemp(paramType) + } + + val ctorMethod = typeMapper.mapToCallableMethod(ctorDesc, false) + val sig = ctorMethod.getAsmMethod().descriptor + + iv.invokespecial( + typeMapper.mapSupertype(superclass.defaultType, null).internalName, + "", sig, false + ) + } + iv.load(0, classType) + if (scriptDefinition.implicitReceivers.isNotEmpty()) { val receiversParamIndex = frameMap.enterTemp(AsmUtil.getArrayType(OBJECT_TYPE)) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.java index c8433d64614..010c958b4a7 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.java @@ -1607,9 +1607,7 @@ public class KotlinTypeMapper { @NotNull public JvmMethodSignature mapScriptSignature( @NotNull ScriptDescriptor script, - @NotNull List importedScripts, - List implicitReceivers, - List> environmentVariables + @NotNull List importedScripts ) { JvmSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD); @@ -1619,14 +1617,6 @@ public class KotlinTypeMapper { writeParameter(sw, DescriptorUtilsKt.getModule(script).getBuiltIns().getArray().getDefaultType(), null); } - if (implicitReceivers.size() > 0) { - writeParameter(sw, DescriptorUtilsKt.getModule(script).getBuiltIns().getArray().getDefaultType(), null); - } - - if (environmentVariables.size() > 0) { - writeParameter(sw, DescriptorUtilsKt.getModule(script).getBuiltIns().getMap().getDefaultType(), null); - } - for (ValueParameterDescriptor valueParameter : script.getUnsubstitutedPrimaryConstructor().getValueParameters()) { writeParameter(sw, valueParameter.getType(), /* callableDescriptor = */ null); } diff --git a/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTypeUtil.kt b/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTypeUtil.kt index 80638bf4d28..455a4c8abb6 100644 --- a/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTypeUtil.kt +++ b/compiler/frontend.script/src/org/jetbrains/kotlin/script/scriptTypeUtil.kt @@ -16,14 +16,12 @@ package org.jetbrains.kotlin.script -import org.jetbrains.kotlin.descriptors.NotFoundClasses -import org.jetbrains.kotlin.descriptors.ScriptDescriptor +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations -import org.jetbrains.kotlin.descriptors.findNonGenericClassAcrossDependencies import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.descriptorUtil.module +import org.jetbrains.kotlin.resolve.lazy.descriptors.script.classId import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.types.* import kotlin.reflect.KClass @@ -33,19 +31,27 @@ import kotlin.reflect.KVariance import kotlin.reflect.full.primaryConstructor fun KotlinScriptDefinition.getScriptParameters(scriptDescriptor: ScriptDescriptor): List = - template.primaryConstructor?.parameters - ?.map { ScriptParameter(Name.identifier(it.name!!), getKotlinTypeByKType(scriptDescriptor, it.type)) } - ?: emptyList() + template.primaryConstructor?.parameters + ?.map { ScriptParameter(Name.identifier(it.name!!), getKotlinTypeByKType(scriptDescriptor, it.type)) } + ?: emptyList() fun getKotlinTypeByKClass(scriptDescriptor: ScriptDescriptor, kClass: KClass): KotlinType = - getKotlinTypeByFqName(scriptDescriptor, - kClass.qualifiedName ?: throw RuntimeException("Cannot get FQN from $kClass")) + getClassDescriptorByKClassOrMock(scriptDescriptor, kClass).defaultType -private fun getKotlinTypeByFqName(scriptDescriptor: ScriptDescriptor, fqName: String): KotlinType = - scriptDescriptor.module.findNonGenericClassAcrossDependencies( - ClassId.topLevel(FqName(fqName)), - NotFoundClasses(LockBasedStorageManager.NO_LOCKS, scriptDescriptor.module) - ).defaultType +fun getClassDescriptorByKClass(scriptDescriptor: ScriptDescriptor, kClass: KClass): ClassDescriptor? = + scriptDescriptor.module.findClassAcrossModuleDependencies(kClass.classId) + +fun getMockClassDescriptor(scriptDescriptor: ScriptDescriptor, kClass: KClass): ClassDescriptor { + val classId = kClass.classId + val typeParametersCount = generateSequence(classId, ClassId::getOuterClassId).map { 0 }.toList() + return NotFoundClasses(LockBasedStorageManager.NO_LOCKS, scriptDescriptor.module).getClass(classId, typeParametersCount) +} + +fun getClassDescriptorByKClassOrMock(scriptDescriptor: ScriptDescriptor, kClass: KClass): ClassDescriptor = + scriptDescriptor.module.findNonGenericClassAcrossDependencies( + kClass.classId, + NotFoundClasses(LockBasedStorageManager.NO_LOCKS, scriptDescriptor.module) + ) // TODO: support star projections // TODO: support annotations on types and type parameters diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 75fe6c11c3d..908084707e2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -98,6 +98,7 @@ public interface Errors { DiagnosticFactory2 API_NOT_AVAILABLE = DiagnosticFactory2.create(ERROR); DiagnosticFactory1 MISSING_DEPENDENCY_CLASS = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 MISSING_SCRIPT_BASE_CLASS = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 MISSING_SCRIPT_RECEIVER_CLASS = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 MISSING_SCRIPT_ENVIRONMENT_PROPERTY_CLASS = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 PRE_RELEASE_CLASS = DiagnosticFactory1.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 3d0b355c1fd..58e02b173a6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -357,6 +357,7 @@ public class DefaultErrorMessages { MAP.put(API_NOT_AVAILABLE, "This declaration is only available since Kotlin {0} and cannot be used with the specified API version {1}", STRING, STRING); MAP.put(MISSING_DEPENDENCY_CLASS, "Cannot access class ''{0}''. Check your module classpath for missing or conflicting dependencies", TO_STRING); + MAP.put(MISSING_SCRIPT_BASE_CLASS, "Cannot access script base class ''{0}''. Check your module classpath for missing or conflicting dependencies", TO_STRING); MAP.put(MISSING_SCRIPT_RECEIVER_CLASS, "Cannot access implicit script receiver class ''{0}''. Check your module classpath for missing or conflicting dependencies", TO_STRING); MAP.put(MISSING_SCRIPT_ENVIRONMENT_PROPERTY_CLASS, "Cannot access script environment property class ''{0}''. Check your module classpath for missing or conflicting dependencies", TO_STRING); MAP.put(PRE_RELEASE_CLASS, "{0} is compiled by a pre-release version of Kotlin and cannot be loaded by this version of the compiler", TO_STRING); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt index 1d8c4f6b8c1..fdc604a1030 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt @@ -22,9 +22,11 @@ import org.jetbrains.kotlin.descriptors.impl.ClassConstructorDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider -import org.jetbrains.kotlin.script.ScriptHelper +import org.jetbrains.kotlin.types.* +import org.jetbrains.kotlin.types.typeUtil.asTypeProjection class LazyScriptClassMemberScope( resolveSession: ResolveSession, @@ -33,34 +35,67 @@ class LazyScriptClassMemberScope( trace: BindingTrace ) : LazyClassMemberScope(resolveSession, declarationProvider, scriptDescriptor, trace) { - override fun resolvePrimaryConstructor(): ClassConstructorDescriptor? { - val constructor = ClassConstructorDescriptorImpl.create( - scriptDescriptor, - Annotations.EMPTY, - true, - SourceElement.NO_SOURCE - ) - constructor.initialize( - createScriptParameters(constructor), - Visibilities.PUBLIC - ) - setDeferredReturnType(constructor) - return constructor + private val scriptPrimaryConstructor: () -> ClassConstructorDescriptorImpl? = resolveSession.storageManager.createNullableLazyValue { + val baseClass = scriptDescriptor.baseClassDescriptor() + val baseConstructorDescriptor = baseClass?.unsubstitutedPrimaryConstructor + if (baseConstructorDescriptor != null) { + val builtIns = scriptDescriptor.builtIns + val implicitReceiversParamType = + if (scriptDescriptor.scriptDefinition().implicitReceivers.isEmpty()) null + else { + "implicitReceivers" to builtIns.array.substitute(builtIns.anyType)!! + } + val environmentVarsParamType = + if (scriptDescriptor.scriptDefinition().environmentVariables.isEmpty()) null + else { + "environmentVariables" to builtIns.map.substitute(builtIns.stringType, builtIns.nullableAnyType)!! + } + val annotations = baseConstructorDescriptor.annotations + val constructorDescriptor = ClassConstructorDescriptorImpl.create( + scriptDescriptor, annotations, baseConstructorDescriptor.isPrimary, scriptDescriptor.source + ) + var paramsIndexBase = baseConstructorDescriptor.valueParameters.let { if (it.isEmpty()) 0 else it.last().index + 1 } + val syntheticParameters = + listOf(implicitReceiversParamType, environmentVarsParamType).mapNotNull { param: Pair? -> + if (param == null) null + else ValueParameterDescriptorImpl( + constructorDescriptor, + null, + paramsIndexBase++, + Annotations.EMPTY, + Name.identifier(param.first), + param.second, + false, false, false, null, SourceElement.NO_SOURCE + ) + } + val parameters = baseConstructorDescriptor.valueParameters.map { it.copy(constructorDescriptor, it.name, it.index) } + + syntheticParameters + constructorDescriptor.initialize(parameters, baseConstructorDescriptor.visibility) + constructorDescriptor.returnType = scriptDescriptor.defaultType + constructorDescriptor + } else { + null + } } - private fun createScriptParameters(constructor: ClassConstructorDescriptorImpl): List { - return ScriptHelper.getInstance().getScriptParameters(scriptDescriptor.scriptDefinition, scriptDescriptor) - .mapIndexed { index, (name, type) -> - ValueParameterDescriptorImpl( - constructor, null, index, Annotations.EMPTY, name, type, - /* declaresDefaultValue = */ false, - /* isCrossinline = */ false, - /* isNoinline = */ false, - null, SourceElement.NO_SOURCE + override fun resolvePrimaryConstructor(): ClassConstructorDescriptor? { + val constructor = scriptPrimaryConstructor() + ?: ClassConstructorDescriptorImpl.create( + scriptDescriptor, + Annotations.EMPTY, + true, + SourceElement.NO_SOURCE + ).initialize( + emptyList(), + Visibilities.PUBLIC ) - } + setDeferredReturnType(constructor) + return constructor } override fun createPropertiesFromPrimaryConstructorParameters(name: Name, result: MutableSet) { } } + +private fun ClassDescriptor.substitute(vararg types: KotlinType): KotlinType? = + KotlinTypeFactory.simpleType(this.defaultType, arguments = types.map { it.asTypeProjection() }) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt index 926302e1bcf..0a7185ed76b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1 import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns @@ -31,14 +30,15 @@ import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.lazy.data.KtScriptInfo import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider import org.jetbrains.kotlin.resolve.lazy.descriptors.script.ScriptEnvironmentDescriptor -import org.jetbrains.kotlin.resolve.scopes.* +import org.jetbrains.kotlin.resolve.lazy.descriptors.script.classId +import org.jetbrains.kotlin.resolve.scopes.LexicalScope +import org.jetbrains.kotlin.resolve.scopes.LexicalScopeImpl +import org.jetbrains.kotlin.resolve.scopes.LexicalScopeKind import org.jetbrains.kotlin.resolve.source.toSourceElement import org.jetbrains.kotlin.script.KotlinScriptDefinition -import org.jetbrains.kotlin.script.ScriptHelper import org.jetbrains.kotlin.script.ScriptPriorities import org.jetbrains.kotlin.script.getScriptDefinition import org.jetbrains.kotlin.types.TypeSubstitutor -import org.jetbrains.kotlin.utils.ifEmpty import kotlin.reflect.KClass import kotlin.reflect.KType @@ -66,11 +66,10 @@ class LazyScriptDescriptor( override fun getPriority() = priority - val scriptDefinition: KotlinScriptDefinition - by lazy { - val file = scriptInfo.script.containingKtFile - getScriptDefinition(file) ?: throw RuntimeException("file ${file.name} is not a script") - } + val scriptDefinition: () -> KotlinScriptDefinition = resolveSession.storageManager.createLazyValue { + val file = scriptInfo.script.containingKtFile + getScriptDefinition(file) ?: throw RuntimeException("file ${file.name} is not a script") + } override fun substitute(substitutor: TypeSubstitutor) = this @@ -88,28 +87,39 @@ class LazyScriptDescriptor( override fun getUnsubstitutedPrimaryConstructor() = super.getUnsubstitutedPrimaryConstructor()!! - override fun computeSupertypes() = - listOf(ScriptHelper.getInstance().getKotlinType(this, scriptDefinition.template)).ifEmpty { listOf(builtIns.anyType) } + internal val baseClassDescriptor: () -> ClassDescriptor? = resolveSession.storageManager.createNullableLazyValue { + findTypeDescriptor(scriptDefinition().template, Errors.MISSING_SCRIPT_BASE_CLASS) + } + + override fun computeSupertypes() = listOf(baseClassDescriptor()?.defaultType ?: builtIns.anyType) private val scriptImplicitReceivers: () -> List = resolveSession.storageManager.createLazyValue { - scriptDefinition.implicitReceivers.mapNotNull { receiver -> + scriptDefinition().implicitReceivers.mapNotNull { receiver -> findTypeDescriptor(receiver, Errors.MISSING_SCRIPT_RECEIVER_CLASS) } } - internal fun findTypeDescriptor(type: KType, errorDiagnostic: DiagnosticFactory1): ClassDescriptor? { - val receiverClassId = type.classId - return receiverClassId?.let { - module.findClassAcrossModuleDependencies(it) - } ?: also { + internal fun findTypeDescriptor(kClass: KClass<*>, errorDiagnostic: DiagnosticFactory1): ClassDescriptor? = + findTypeDescriptor(kClass.classId, kClass.toString(), errorDiagnostic) + + internal fun findTypeDescriptor(type: KType, errorDiagnostic: DiagnosticFactory1): ClassDescriptor? = + findTypeDescriptor(type.classId, type.toString(), errorDiagnostic) + + internal fun findTypeDescriptor( + classId: ClassId?, typeName: String, + errorDiagnostic: DiagnosticFactory1 + ): ClassDescriptor? { + val typeDescriptor = classId?.let { module.findClassAcrossModuleDependencies(it) } + if (typeDescriptor == null) { // TODO: use PositioningStrategies to highlight some specific place in case of error, instead of treating the whole file as invalid resolveSession.trace.report( errorDiagnostic.on( scriptInfo.script, - receiverClassId?.asSingleFqName()?.toString() ?: type.toString() + classId?.asSingleFqName()?.toString() ?: typeName ) ) } + return typeDescriptor } override fun getImplicitReceivers(): List = scriptImplicitReceivers() @@ -123,7 +133,7 @@ class LazyScriptDescriptor( private val scriptOuterScope: () -> LexicalScope = resolveSession.storageManager.createLazyValue { var outerScope = super.getOuterScope() val outerScopeReceivers = implicitReceivers.let { - if (scriptDefinition.environmentVariables.isEmpty()) { + if (scriptDefinition().environmentVariables.isEmpty()) { it } else { it + ScriptEnvironmentDescriptor(this) @@ -143,11 +153,3 @@ class LazyScriptDescriptor( override fun getOuterScope(): LexicalScope = scriptOuterScope() } - -private val KClass<*>.classId: ClassId - get() = this.java.enclosingClass?.kotlin?.classId?.createNestedClassId(Name.identifier(simpleName!!)) - ?: ClassId.topLevel(FqName(qualifiedName!!)) - -private val KType.classId: ClassId? - get() = classifier?.let { it as? KClass<*> }?.classId - diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/script/ScriptEnvironmentDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/script/ScriptEnvironmentDescriptor.kt index 3b3b4f9990e..252f7667e9b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/script/ScriptEnvironmentDescriptor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/script/ScriptEnvironmentDescriptor.kt @@ -43,7 +43,7 @@ class ScriptEnvironmentDescriptor(script: LazyScriptDescriptor) : override fun getUnsubstitutedMemberScope(): MemberScope = memberScope() val properties: () -> List = script.resolveSession.storageManager.createLazyValue { - script.scriptDefinition.environmentVariables.mapNotNull { (name, type) -> + script.scriptDefinition().environmentVariables.mapNotNull { (name, type) -> script.findTypeDescriptor(type, Errors.MISSING_SCRIPT_ENVIRONMENT_PROPERTY_CLASS)?.let { name to it } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/script/scriptDescriptorUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/script/scriptDescriptorUtil.kt new file mode 100644 index 00000000000..cbfca749ecd --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/script/scriptDescriptorUtil.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.resolve.lazy.descriptors.script + +import org.jetbrains.kotlin.name.ClassId +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import kotlin.reflect.KClass +import kotlin.reflect.KType + +val KClass<*>.classId: ClassId + get() = this.java.enclosingClass?.kotlin?.classId?.createNestedClassId(Name.identifier(simpleName!!)) + ?: ClassId.topLevel(FqName(qualifiedName!!)) + +val KType.classId: ClassId? + get() = classifier?.let { it as? KClass<*> }?.classId diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt index 6d0f2adaa89..28c773a7926 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt @@ -84,7 +84,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { override fun getPresentableName() = KOTLIN_BUILDER_NAME - override fun getCompilableFileExtensions() = arrayListOf("kt") + override fun getCompilableFileExtensions() = arrayListOf("kt", "kts") override fun buildStarted(context: CompileContext) { LOG.debug("==========================================")