azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Get rid of underscores in private property names

Browse Source 
They were used to workaround duplicate signature errors, but this is no longer
relevant since no accessors are generated for private properties with backing
fields
This commit is contained in:
Alexander Udalov
2014-11-11 15:25:08 +03:00
parent bb96a8e1fb
commit eb96b97bc8
15 changed files with 130 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend-common/src/bridges/impl.kt
+2 -2
View File
@@ -47,7 +47,7 @@ public fun <Signature> generateBridgesForFunctionDescriptor(
* eases the process of determining what bridges are already generated in our supertypes and need to be inherited, not regenerated.
*/
private data class DescriptorBasedFunctionHandle(val descriptor: FunctionDescriptor) : FunctionHandle {
private val _overridden = descriptor.getOverriddenDescriptors().map { DescriptorBasedFunctionHandle(it.getOriginal()) }
private val overridden = descriptor.getOverriddenDescriptors().map { DescriptorBasedFunctionHandle(it.getOriginal()) }
override val isDeclaration: Boolean =
descriptor.getKind().isReal() ||
@@ -57,7 +57,7 @@ private data class DescriptorBasedFunctionHandle(val descriptor: FunctionDescrip
descriptor.getModality() == Modality.ABSTRACT ||
DescriptorUtils.isTrait(descriptor.getContainingDeclaration())
override fun getOverridden() = _overridden
override fun getOverridden() = overridden
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt
+4 -6
View File
@@ -94,7 +94,7 @@ public class IncrementalPackageFragmentProvider(
public val moduleId: String
get() = this@IncrementalPackageFragmentProvider.moduleId
val _memberScope: NotNullLazyValue<JetScope> = storageManager.createLazyValue {
val memberScope: NotNullLazyValue<JetScope> = storageManager.createLazyValue {
if (fqName !in fqNamesToLoad) {
JetScope.Empty
}
@@ -109,16 +109,14 @@ public class IncrementalPackageFragmentProvider(
}
}
override fun getMemberScope(): JetScope {
return _memberScope()
}
override fun getMemberScope(): JetScope = memberScope()
private inner class IncrementalPackageScope(val packageData: PackageData) : DeserializedPackageMemberScope(
this@IncrementalPackageFragment,
packageData.getPackageProto(),
deserializationContext.withNameResolver(packageData.getNameResolver()),
{ listOf() }) {
{ listOf() }
) {
override fun filteredMemberProtos(allMemberProtos: Collection<ProtoBuf.Callable>): Collection<ProtoBuf.Callable> {
return allMemberProtos
.filter {
compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/instructions/LexicalScope.kt
+2 -2
View File
@@ -22,8 +22,8 @@ import kotlin.properties.Delegates
public class LexicalScope(val parentScope: LexicalScope?, val element: JetElement) {
//todo remove after KT-4126
private val _d = (parentScope?.depth ?: 0) + 1
val depth: Int get() = _d
private val d = (parentScope?.depth ?: 0) + 1
val depth: Int get() = d
val lexicalScopeForContainingDeclaration: LexicalScope? by Delegates.lazy { computeLexicalScopeForContainingDeclaration() }
private fun computeLexicalScopeForContainingDeclaration(): LexicalScope? {
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt
+26 -26
View File
@@ -31,76 +31,76 @@ public abstract class JetCodeFragment(
name: String,
text: CharSequence,
elementType: IElementType,
private val _context: PsiElement?
private val context: PsiElement?
): JetFile((PsiManager.getInstance(_project) as PsiManagerEx).getFileManager().createFileViewProvider(LightVirtualFile(name, JetFileType.INSTANCE, text), true), false), JavaCodeFragment {
private var _viewProvider = super<JetFile>.getViewProvider() as SingleRootFileViewProvider
private var _myImports = HashSet<String>();
private var viewProvider = super<JetFile>.getViewProvider() as SingleRootFileViewProvider
private var myImports = HashSet<String>();
{
getViewProvider().forceCachedPsi(this)
init(TokenType.CODE_FRAGMENT, elementType)
if (_context != null) {
addImportsFromString(getImportsForElement(_context))
if (context != null) {
addImportsFromString(getImportsForElement(context))
}
}
private var _resolveScope: GlobalSearchScope? = null
private var _thisType: PsiType? = null
private var _superType: PsiType? = null
private var _exceptionHandler: JavaCodeFragment.ExceptionHandler? = null
private var resolveScope: GlobalSearchScope? = null
private var thisType: PsiType? = null
private var superType: PsiType? = null
private var exceptionHandler: JavaCodeFragment.ExceptionHandler? = null
public abstract fun getContentElement(): JetElement?
override fun forceResolveScope(scope: GlobalSearchScope?) {
_resolveScope = scope
resolveScope = scope
}
override fun getForcedResolveScope() = _resolveScope
override fun getForcedResolveScope() = resolveScope
override fun isPhysical() = true
override fun isValid() = true
override fun getContext() = _context
override fun getContext() = context
override fun getResolveScope() = _resolveScope ?: super<JetFile>.getResolveScope()
override fun getResolveScope() = resolveScope ?: super<JetFile>.getResolveScope()
override fun clone(): JetCodeFragment {
val clone = cloneImpl(calcTreeElement().clone() as FileElement) as JetCodeFragment
clone.setOriginalFile(this)
clone._myImports = _myImports
clone._viewProvider = SingleRootFileViewProvider(PsiManager.getInstance(_project), LightVirtualFile(getName(), JetFileType.INSTANCE, getText()), true)
clone._viewProvider.forceCachedPsi(clone)
clone.myImports = myImports
clone.viewProvider = SingleRootFileViewProvider(PsiManager.getInstance(_project), LightVirtualFile(getName(), JetFileType.INSTANCE, getText()), true)
clone.viewProvider.forceCachedPsi(clone)
return clone
}
override fun getViewProvider() = _viewProvider
override fun getViewProvider() = viewProvider
override fun getThisType() = _thisType
override fun getThisType() = thisType
override fun setThisType(psiType: PsiType?) {
_thisType = psiType
thisType = psiType
}
override fun getSuperType() = _superType
override fun getSuperType() = superType
override fun setSuperType(superType: PsiType?) {
_superType = superType
$superType = superType
}
override fun importsToString(): String {
return _myImports.makeString(IMPORT_SEPARATOR)
return myImports.makeString(IMPORT_SEPARATOR)
}
override fun addImportsFromString(imports: String?) {
if (imports == null || imports.isEmpty()) return
_myImports.addAll(imports.split(IMPORT_SEPARATOR))
myImports.addAll(imports.split(IMPORT_SEPARATOR))
}
public fun importsAsImportList(): JetImportList? {
return JetPsiFactory(this).createFile(_myImports.makeString("\n")).getImportList()
return JetPsiFactory(this).createFile(myImports.makeString("\n")).getImportList()
}
override fun setVisibilityChecker(checker: JavaCodeFragment.VisibilityChecker?) { }
@@ -108,10 +108,10 @@ public abstract class JetCodeFragment(
override fun getVisibilityChecker() = JavaCodeFragment.VisibilityChecker.EVERYTHING_VISIBLE
override fun setExceptionHandler(checker: JavaCodeFragment.ExceptionHandler?) {
_exceptionHandler = checker
exceptionHandler = checker
}
override fun getExceptionHandler() = _exceptionHandler
override fun getExceptionHandler() = exceptionHandler
override fun importClass(aClass: PsiClass?): Boolean {
return true
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt
+11 -11
View File
@@ -53,7 +53,7 @@ public class LazyAnnotations(
) : Annotations, LazyEntity {
override fun isEmpty() = annotationEntries.isEmpty()
val _annotation = c.storageManager.createMemoizedFunction {
private val annotation = c.storageManager.createMemoizedFunction {
(entry: JetAnnotationEntry) ->
LazyAnnotationDescriptor(c, entry)
}
@@ -77,7 +77,7 @@ public class LazyAnnotations(
}
override fun iterator(): Iterator<AnnotationDescriptor> {
return annotationEntries.stream().map(_annotation).iterator()
return annotationEntries.stream().map(annotation).iterator()
}
override fun forceResolveAllContents() {
@@ -95,7 +95,7 @@ public class LazyAnnotationDescriptor(
c.trace.record(BindingContext.ANNOTATION, annotationEntry, this)
}
private val _resolutionResults = c.storageManager.createLazyValue {
private val resolutionResults = c.storageManager.createLazyValue {
val results = c.annotationResolver.resolveAnnotationCall(
annotationEntry,
c.scope,
@@ -105,33 +105,33 @@ public class LazyAnnotationDescriptor(
results
}
private val _type = c.storageManager.createLazyValue {
private val type = c.storageManager.createLazyValue {
c.annotationResolver.resolveAnnotationType(
c.scope,
annotationEntry
)
}
override fun getType() = _type()
override fun getType() = type()
private val _valueArguments = c.storageManager.createMemoizedFunctionWithNullableValues @f {
private val valueArguments = c.storageManager.createMemoizedFunctionWithNullableValues @f {
(valueParameterDescriptor: ValueParameterDescriptor): CompileTimeConstant<*>? ->
if (!_resolutionResults().isSingleResult()) return@f null
if (!resolutionResults().isSingleResult()) return@f null
val resolvedValueArgument = _resolutionResults().getResultingCall().getValueArguments()[valueParameterDescriptor]
val resolvedValueArgument = resolutionResults().getResultingCall().getValueArguments()[valueParameterDescriptor]
if (resolvedValueArgument == null) return@f null
AnnotationResolver.getAnnotationArgumentValue(c.trace, valueParameterDescriptor, resolvedValueArgument)
}
override fun getValueArgument(valueParameterDescriptor: ValueParameterDescriptor): CompileTimeConstant<out Any?>? {
return _valueArguments(valueParameterDescriptor)
return valueArguments(valueParameterDescriptor)
}
override fun getAllValueArguments(): Map<ValueParameterDescriptor, CompileTimeConstant<out Any?>> {
if (!_resolutionResults().isSingleResult()) return mapOf()
if (!resolutionResults().isSingleResult()) return mapOf()
return _resolutionResults().getResultingCall().getValueArguments().keySet().keysToMapExceptNulls {
return resolutionResults().getResultingCall().getValueArguments().keySet().keysToMapExceptNulls {
getValueArgument(it)
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyScriptDescriptor.kt
+10 -10
View File
@@ -43,10 +43,10 @@ import org.jetbrains.jet.lang.descriptors.PropertyDescriptor
import org.jetbrains.jet.lang.resolve.source.toSourceElement
public class LazyScriptDescriptor(
val resolveSession: ResolveSession,
private val resolveSession: ResolveSession,
scriptBodyResolver: ScriptBodyResolver,
val jetScript: JetScript,
val _priority: Int
private val jetScript: JetScript,
private val priority: Int
) : ScriptDescriptor, LazyEntity, DeclarationDescriptorNonRootImpl(
jetScript.getContainingJetFile().getPackageFqName().let {
fqName ->
@@ -60,20 +60,20 @@ public class LazyScriptDescriptor(
resolveSession.getTrace().record(BindingContext.SCRIPT, jetScript, this)
}
private val _implicitReceiver = ReceiverParameterDescriptorImpl(this, KotlinBuiltIns.getInstance().getAnyType(), ScriptReceiver(this))
private val implicitReceiver = ReceiverParameterDescriptorImpl(this, KotlinBuiltIns.getInstance().getAnyType(), ScriptReceiver(this))
override fun getThisAsReceiverParameter() = _implicitReceiver
override fun getThisAsReceiverParameter() = implicitReceiver
override fun getPriority() = _priority
override fun getPriority() = priority
override fun getClassDescriptor() = resolveSession.getClassDescriptorForScript(jetScript) as LazyScriptClassDescriptor
override fun getScriptResultProperty(): PropertyDescriptor = getClassDescriptor().getScopeForMemberLookup().getScriptResultProperty()
private val _scriptCodeDescriptor = resolveSession.getStorageManager().createLazyValue {
private val scriptCodeDescriptor = resolveSession.getStorageManager().createLazyValue {
val result = ScriptCodeDescriptor(this)
result.initialize(
_implicitReceiver,
implicitReceiver,
ScriptParameterResolver.resolveScriptParameters(jetScript, this),
DeferredType.create(resolveSession.getStorageManager(), resolveSession.getTrace()) {
scriptBodyResolver.resolveScriptReturnType(jetScript, this, resolveSession.getTrace())
@@ -82,11 +82,11 @@ public class LazyScriptDescriptor(
result
}
override fun getScriptCodeDescriptor() = _scriptCodeDescriptor()
override fun getScriptCodeDescriptor() = scriptCodeDescriptor()
override fun getScopeForBodyResolution(): JetScope {
val parametersScope = WritableScopeImpl(JetScope.Empty, this, RedeclarationHandler.DO_NOTHING, "Parameters of " + this)
parametersScope.setImplicitReceiver(_implicitReceiver)
parametersScope.setImplicitReceiver(implicitReceiver)
for (valueParameterDescriptor in getScriptCodeDescriptor().getValueParameters()) {
parametersScope.addVariableDescriptor(valueParameterDescriptor)
}
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt
+2 -2
View File
@@ -48,7 +48,7 @@ public class LazyJavaPackageFragmentProvider(
outerContext.moduleClassResolver
)
private val _packageFragments: MemoizedFunctionToNullable<FqName, LazyJavaPackageFragment> =
private val packageFragments: MemoizedFunctionToNullable<FqName, LazyJavaPackageFragment> =
c.storageManager.createMemoizedFunctionWithNullableValues {
fqName ->
val jPackage = c.finder.findPackage(fqName)
@@ -74,7 +74,7 @@ public class LazyJavaPackageFragmentProvider(
)
}
fun getPackageFragment(fqName: FqName) = _packageFragments(fqName)
fun getPackageFragment(fqName: FqName) = packageFragments(fqName)
override fun getPackageFragments(fqName: FqName) = getPackageFragment(fqName)?.let {listOf(it)}.orEmpty()
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt
+2 -2
View File
@@ -60,7 +60,7 @@ class LazyJavaAnnotationDescriptor(
else kotlinFqNameToJavaFqName(classId.asSingleFqName())
}
private val _type = c.storageManager.createLazyValue {() : JetType ->
private val type = c.storageManager.createLazyValue {(): JetType ->
val fqName = fqName()
if (fqName == null) return@createLazyValue ErrorUtils.createErrorType("No fqName: $javaAnnotation")
val annotationClass = JavaToKotlinClassMap.getInstance().mapKotlinClass(fqName, TypeUsage.MEMBER_SIGNATURE_INVARIANT)
@@ -68,7 +68,7 @@ class LazyJavaAnnotationDescriptor(
annotationClass?.getDefaultType() ?: ErrorUtils.createErrorType(fqName.asString())
}
override fun getType(): JetType = _type()
override fun getType(): JetType = type()
private val nameToArgument = c.storageManager.createLazyValue {
var arguments: Collection<JavaAnnotationArgument> = javaAnnotation.getArguments()
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt
+30 -30
View File
@@ -49,70 +49,70 @@ class LazyJavaClassDescriptor(
c.javaResolverCache.recordClass(jClass, this)
}
private val _kind = when {
private val kind = when {
jClass.isAnnotationType() -> ClassKind.ANNOTATION_CLASS
jClass.isInterface() -> ClassKind.TRAIT
jClass.isEnum() -> ClassKind.ENUM_CLASS
else -> ClassKind.CLASS
}
private val _modality = if (jClass.isAnnotationType())
Modality.FINAL
else Modality.convertFromFlags(jClass.isAbstract() || jClass.isInterface(), !jClass.isFinal())
private val modality = if (jClass.isAnnotationType())
Modality.FINAL
else Modality.convertFromFlags(jClass.isAbstract() || jClass.isInterface(), !jClass.isFinal())
private val _visibility = jClass.getVisibility()
private val _isInner = jClass.getOuterClass() != null && !jClass.isStatic()
private val visibility = jClass.getVisibility()
private val isInner = jClass.getOuterClass() != null && !jClass.isStatic()
override fun getKind() = _kind
override fun getModality() = _modality
override fun getVisibility() = _visibility
override fun isInner() = _isInner
override fun getKind() = kind
override fun getModality() = modality
override fun getVisibility() = visibility
override fun isInner() = isInner
private val _typeConstructor = c.storageManager.createLazyValue { LazyJavaClassTypeConstructor() }
override fun getTypeConstructor(): TypeConstructor = _typeConstructor()
private val typeConstructor = c.storageManager.createLazyValue { LazyJavaClassTypeConstructor() }
override fun getTypeConstructor(): TypeConstructor = typeConstructor()
private val _scopeForMemberLookup = LazyJavaClassMemberScope(c, this, jClass)
override fun getScopeForMemberLookup() = _scopeForMemberLookup
private val scopeForMemberLookup = LazyJavaClassMemberScope(c, this, jClass)
override fun getScopeForMemberLookup() = scopeForMemberLookup
private val _innerClassesScope = InnerClassesScopeWrapper(getScopeForMemberLookup())
override fun getUnsubstitutedInnerClassesScope(): JetScope = _innerClassesScope
private val innerClassesScope = InnerClassesScopeWrapper(getScopeForMemberLookup())
override fun getUnsubstitutedInnerClassesScope(): JetScope = innerClassesScope
private val _staticScope = LazyJavaStaticClassScope(c, jClass, this)
override fun getStaticScope(): JetScope = _staticScope
private val staticScope = LazyJavaStaticClassScope(c, jClass, this)
override fun getStaticScope(): JetScope = staticScope
override fun getUnsubstitutedPrimaryConstructor(): ConstructorDescriptor? = null
override fun getClassObjectDescriptor(): ClassDescriptor? = null
override fun getClassObjectType(): JetType? = getClassObjectDescriptor()?.let { d -> d.getDefaultType() }
override fun getConstructors() = _scopeForMemberLookup.constructors()
override fun getConstructors() = scopeForMemberLookup.constructors()
private val _annotations = c.storageManager.createLazyValue { c.resolveAnnotations(jClass) }
override fun getAnnotations() = _annotations()
private val annotations = c.storageManager.createLazyValue { c.resolveAnnotations(jClass) }
override fun getAnnotations() = annotations()
private val _functionTypeForSamInterface = c.storageManager.createNullableLazyValue {
private val functionTypeForSamInterface = c.storageManager.createNullableLazyValue {
c.samConversionResolver.resolveFunctionTypeIfSamInterface(this) { method ->
_scopeForMemberLookup.resolveMethodToFunctionDescriptor(method, false)
scopeForMemberLookup.resolveMethodToFunctionDescriptor(method, false)
}
}
override fun getFunctionTypeForSamInterface(): JetType? = _functionTypeForSamInterface()
override fun getFunctionTypeForSamInterface(): JetType? = functionTypeForSamInterface()
override fun toString() = "lazy java class $fqName"
private inner class LazyJavaClassTypeConstructor : AbstractClassTypeConstructor() {
private val _parameters = c.storageManager.createLazyValue {
jClass.getTypeParameters().map({
private val parameters = c.storageManager.createLazyValue {
jClass.getTypeParameters().map {
p ->
c.typeParameterResolver.resolveTypeParameter(p)
?: throw AssertionError("Parameter $p surely belongs to class ${jClass}, so it must be resolved")
})
}
}
override fun getParameters(): List<TypeParameterDescriptor> = _parameters()
override fun getParameters(): List<TypeParameterDescriptor> = parameters()
private val _supertypes = c.storageManager.createLazyValue<Collection<JetType>> {
private val supertypes = c.storageManager.createLazyValue<Collection<JetType>> {
jClass.getSupertypes().stream()
.map {
supertype ->
@@ -125,7 +125,7 @@ class LazyJavaClassDescriptor(
}
}
override fun getSupertypes(): Collection<JetType> = _supertypes()
override fun getSupertypes(): Collection<JetType> = supertypes()
override fun getAnnotations() = Annotations.EMPTY
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt
+6 -6
View File
@@ -47,9 +47,9 @@ import org.jetbrains.jet.lang.descriptors.annotations.Annotations
public abstract class LazyJavaMemberScope(
protected val c: LazyJavaResolverContextWithTypes,
private val _containingDeclaration: DeclarationDescriptor
private val containingDeclaration: DeclarationDescriptor
) : JetScope {
private val _allDescriptors = c.storageManager.createRecursionTolerantLazyValue<Collection<DeclarationDescriptor>>(
private val allDescriptors = c.storageManager.createRecursionTolerantLazyValue<Collection<DeclarationDescriptor>>(
{computeAllDescriptors()},
// This is to avoid the following recursive case:
// when computing getAllPackageNames() we ask the JavaPsiFacade for all subpackages of foo
@@ -58,7 +58,7 @@ public abstract class LazyJavaMemberScope(
listOf()
)
override fun getContainingDeclaration() = _containingDeclaration
override fun getContainingDeclaration() = containingDeclaration
protected val memberIndex: NotNullLazyValue<MemberIndex> = c.storageManager.createLazyValue {
computeMemberIndex()
@@ -105,7 +105,7 @@ public abstract class LazyJavaMemberScope(
val annotations = c.resolveAnnotations(method)
val functionDescriptorImpl = JavaMethodDescriptor.createJavaMethod(
_containingDeclaration, annotations, method.getName(), c.sourceElementFactory.source(method)
containingDeclaration, annotations, method.getName(), c.sourceElementFactory.source(method)
)
val c = c.child(functionDescriptorImpl, method.getTypeParameters().toSet())
@@ -255,7 +255,7 @@ public abstract class LazyJavaMemberScope(
val annotations = c.resolveAnnotations(field)
val propertyName = field.getName()
return JavaPropertyDescriptor(_containingDeclaration, annotations, visibility, isVar, propertyName,
return JavaPropertyDescriptor(containingDeclaration, annotations, visibility, isVar, propertyName,
c.sourceElementFactory.source(field))
}
@@ -283,7 +283,7 @@ public abstract class LazyJavaMemberScope(
override fun getDeclarationsByLabel(labelName: Name) = listOf<DeclarationDescriptor>()
override fun getOwnDeclaredDescriptors() = getAllDescriptors()
override fun getAllDescriptors() = _allDescriptors()
override fun getAllDescriptors() = allDescriptors()
private fun computeAllDescriptors(): List<DeclarationDescriptor> {
val result = LinkedHashSet<DeclarationDescriptor>()
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragment.kt
+2 -2
View File
@@ -25,9 +25,9 @@ class LazyJavaPackageFragment(
private val c: LazyJavaResolverContext,
private val jPackage: JavaPackage
) : PackageFragmentDescriptorImpl(c.packageFragmentProvider.module, jPackage.getFqName()) {
private val _memberScope by Delegates.lazy { LazyPackageFragmentScopeForJavaPackage(c, jPackage, this) }
private val scope by Delegates.lazy { LazyPackageFragmentScopeForJavaPackage(c, jPackage, this) }
override fun getMemberScope() = _memberScope
override fun getMemberScope() = scope
override fun toString() = "lazy java package fragment: $fqName"
}
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt
+2 -2
View File
@@ -116,7 +116,7 @@ public class LazyPackageFragmentScopeForJavaPackage(
.map { c -> c.getName() }.toList()
}
private val _subPackages = c.storageManager.createRecursionTolerantLazyValue(
private val subPackages = c.storageManager.createRecursionTolerantLazyValue(
{
jPackage.getSubPackages().map { sp -> sp.getFqName() }
},
@@ -128,7 +128,7 @@ public class LazyPackageFragmentScopeForJavaPackage(
result.addIfNotNull(c.samConversionResolver.resolveSamConstructor(name, this))
}
override fun getSubPackages() = _subPackages()
override fun getSubPackages() = subPackages()
override fun getAllPropertyNames() = Collections.emptyList<Name>()
}
core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt
+5 -5
View File
@@ -35,7 +35,6 @@ import org.jetbrains.jet.lang.resolve.java.PLATFORM_TYPES
import org.jetbrains.jet.lang.resolve.java.lazy.types.JavaTypeFlexibility.*
import org.jetbrains.jet.lang.descriptors.annotations.Annotations
import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames
import org.jetbrains.jet.lang.resolve.name.FqName
import kotlin.platform.platformStatic
class LazyJavaTypeResolver(
@@ -248,11 +247,11 @@ class LazyJavaTypeResolver(
return (descriptor as ClassDescriptor).getMemberScope(getArguments())
}
private val _nullable = c.storageManager.createLazyValue @nullable{
private val nullable = c.storageManager.createLazyValue @l {
(): Boolean ->
when (attr.flexibility) {
FLEXIBLE_LOWER_BOUND -> return@nullable false
FLEXIBLE_UPPER_BOUND -> return@nullable true
FLEXIBLE_LOWER_BOUND -> return@l false
FLEXIBLE_UPPER_BOUND -> return@l true
}
!attr.isMarkedNotNull &&
// 'L extends List<T>' in Java is a List<T> in Kotlin, not a List<T?>
@@ -269,7 +268,8 @@ class LazyJavaTypeResolver(
else -> error("Unknown classifier: ${classifier()}")
}
}
override fun isNullable(): Boolean = _nullable()
override fun isNullable(): Boolean = nullable()
override fun getAnnotations() = attr.annotations
}
core/descriptors/src/org/jetbrains/jet/lang/types/AbstractLazyType.kt
+8 -8
View File
@@ -22,18 +22,18 @@ import org.jetbrains.jet.lang.descriptors.annotations.Annotations
public abstract class AbstractLazyType(storageManager: StorageManager) : AbstractJetType(), LazyType {
private val _typeConstructor = storageManager.createLazyValue {computeTypeConstructor()}
override fun getConstructor(): TypeConstructor = _typeConstructor()
private val typeConstructor = storageManager.createLazyValue { computeTypeConstructor() }
override fun getConstructor(): TypeConstructor = typeConstructor()
protected abstract fun computeTypeConstructor(): TypeConstructor
private val _arguments = storageManager.createLazyValue {computeArguments()}
override fun getArguments(): List<TypeProjection> = _arguments()
private val arguments = storageManager.createLazyValue { computeArguments() }
override fun getArguments(): List<TypeProjection> = arguments()
protected abstract fun computeArguments(): List<TypeProjection>
private val _memberScope = storageManager.createLazyValue {computeMemberScope()}
override fun getMemberScope() = _memberScope()
private val memberScope = storageManager.createLazyValue { computeMemberScope() }
override fun getMemberScope() = memberScope()
protected abstract fun computeMemberScope(): JetScope
@@ -44,10 +44,10 @@ public abstract class AbstractLazyType(storageManager: StorageManager) : Abstrac
override fun getAnnotations() = Annotations.EMPTY
override fun toString(): String {
if (!_typeConstructor.isComputed()) {
if (!typeConstructor.isComputed()) {
return "Type constructor is not computed"
}
if (!_arguments.isComputed()) {
if (!arguments.isComputed()) {
return "" + getConstructor() + "<arguments are not computed>"
}
return super<AbstractJetType>.toString()
idea/src/org/jetbrains/jet/plugin/formatter/SynteticKotlinBlock.kt
+18 -18
View File
@@ -26,35 +26,35 @@ import com.intellij.formatting.Spacing
import com.intellij.lang.ASTNode
import com.intellij.psi.formatter.common.AbstractBlock
import com.intellij.formatting.ASTBlock
import java.util.ArrayList
public class SyntheticKotlinBlock(
private val _node: ASTNode,
private val _subBlocks: MutableList<Block>,
private val _alignment: Alignment?,
private val _indent: Indent?,
private val _wrap: Wrap?,
private val spacingBuilder: KotlinSpacingBuilder) : ASTBlock {
private val node: ASTNode,
private val subBlocks: MutableList<Block>,
private val alignment: Alignment?,
private val indent: Indent?,
private val wrap: Wrap?,
private val spacingBuilder: KotlinSpacingBuilder
) : ASTBlock {
private val _textRange = TextRange(
_subBlocks.first().getTextRange().getStartOffset(),
_subBlocks.last().getTextRange().getEndOffset())
private val textRange = TextRange(
subBlocks.first().getTextRange().getStartOffset(),
subBlocks.last().getTextRange().getEndOffset())
override fun getTextRange(): TextRange = _textRange
override fun getSubBlocks() = _subBlocks
override fun getWrap() = _wrap
override fun getIndent() = _indent
override fun getAlignment() = _alignment
override fun getTextRange(): TextRange = textRange
override fun getSubBlocks() = subBlocks
override fun getWrap() = wrap
override fun getIndent() = indent
override fun getAlignment() = alignment
override fun getChildAttributes(newChildIndex: Int) = ChildAttributes(getIndent(), null)
override fun isIncomplete() = getSubBlocks().last().isIncomplete()
override fun isLeaf() = false
override fun getNode() = _node
override fun getNode() = node
override fun getSpacing(child1: Block?, child2: Block): Spacing? =
spacingBuilder.getSpacing(KotlinSpacingBuilder.SpacingNodeBlock(_node.getTreeParent()!!), child1, child2)
spacingBuilder.getSpacing(KotlinSpacingBuilder.SpacingNodeBlock(node.getTreeParent()!!), child1, child2)
override fun toString(): String {
var child = _subBlocks.first()
var child = subBlocks.first()
var treeNode: ASTNode? = null
while (treeNode == null) when (child) {
is AbstractBlock -> {