From eb96b97bc81ac77cde1c0a2cb90ca19e3c1322a7 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 11 Nov 2014 15:25:08 +0300 Subject: [PATCH] Get rid of underscores in private property names 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 --- compiler/backend-common/src/bridges/impl.kt | 4 +- .../IncrementalPackageFragmentProvider.kt | 10 ++-- .../pseudocode/instructions/LexicalScope.kt | 4 +- .../jetbrains/jet/lang/psi/JetCodeFragment.kt | 52 ++++++++-------- .../lazy/descriptors/LazyAnnotations.kt | 22 +++---- .../lazy/descriptors/LazyScriptDescriptor.kt | 20 +++---- .../lazy/LazyJavaPackageFragmentProvider.kt | 4 +- .../LazyJavaAnnotationDescriptor.kt | 4 +- .../descriptors/LazyJavaClassDescriptor.kt | 60 +++++++++---------- .../lazy/descriptors/LazyJavaMemberScope.kt | 12 ++-- .../descriptors/LazyJavaPackageFragment.kt | 4 +- .../lazy/descriptors/LazyJavaStaticScope.kt | 4 +- .../java/lazy/types/LazyJavaTypeResolver.kt | 10 ++-- .../jet/lang/types/AbstractLazyType.kt | 16 ++--- .../plugin/formatter/SynteticKotlinBlock.kt | 36 +++++------ 15 files changed, 130 insertions(+), 132 deletions(-) diff --git a/compiler/backend-common/src/bridges/impl.kt b/compiler/backend-common/src/bridges/impl.kt index fade885a3dc..bb41319f10c 100644 --- a/compiler/backend-common/src/bridges/impl.kt +++ b/compiler/backend-common/src/bridges/impl.kt @@ -47,7 +47,7 @@ public fun 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 } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt index 6305ef027af..b94b64d7d32 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/incremental/IncrementalPackageFragmentProvider.kt @@ -94,7 +94,7 @@ public class IncrementalPackageFragmentProvider( public val moduleId: String get() = this@IncrementalPackageFragmentProvider.moduleId - val _memberScope: NotNullLazyValue = storageManager.createLazyValue { + val memberScope: NotNullLazyValue = 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): Collection { return allMemberProtos .filter { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/instructions/LexicalScope.kt b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/instructions/LexicalScope.kt index 772610833c4..78ffed69daa 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/instructions/LexicalScope.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/instructions/LexicalScope.kt @@ -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? { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt index 3be18da69bf..77c2d6776e6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt @@ -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.getViewProvider() as SingleRootFileViewProvider - private var _myImports = HashSet(); + private var viewProvider = super.getViewProvider() as SingleRootFileViewProvider + private var myImports = HashSet(); { 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.getResolveScope() + override fun getResolveScope() = resolveScope ?: super.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 diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt index 7b444aa8929..7f08aacabc6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt @@ -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 { - 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? { - return _valueArguments(valueParameterDescriptor) + return valueArguments(valueParameterDescriptor) } override fun getAllValueArguments(): Map> { - if (!_resolutionResults().isSingleResult()) return mapOf() + if (!resolutionResults().isSingleResult()) return mapOf() - return _resolutionResults().getResultingCall().getValueArguments().keySet().keysToMapExceptNulls { + return resolutionResults().getResultingCall().getValueArguments().keySet().keysToMapExceptNulls { getValueArgument(it) } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyScriptDescriptor.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyScriptDescriptor.kt index 174744eb7e6..283f8a46a7f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyScriptDescriptor.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyScriptDescriptor.kt @@ -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) } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt index 747ff258eb1..8b83aca0bf5 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/LazyJavaPackageFragmentProvider.kt @@ -48,7 +48,7 @@ public class LazyJavaPackageFragmentProvider( outerContext.moduleClassResolver ) - private val _packageFragments: MemoizedFunctionToNullable = + private val packageFragments: MemoizedFunctionToNullable = 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() diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index 53a9ccb8e77..db2f35811e0 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt @@ -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 = javaAnnotation.getArguments() diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt index 2bd73a5aade..2453df3b7cf 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassDescriptor.kt @@ -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 = _parameters() + override fun getParameters(): List = parameters() - private val _supertypes = c.storageManager.createLazyValue> { + private val supertypes = c.storageManager.createLazyValue> { jClass.getSupertypes().stream() .map { supertype -> @@ -125,7 +125,7 @@ class LazyJavaClassDescriptor( } } - override fun getSupertypes(): Collection = _supertypes() + override fun getSupertypes(): Collection = supertypes() override fun getAnnotations() = Annotations.EMPTY diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt index c04c37b4e19..789c3829b2b 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt @@ -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>( + private val allDescriptors = c.storageManager.createRecursionTolerantLazyValue>( {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 = 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() override fun getOwnDeclaredDescriptors() = getAllDescriptors() - override fun getAllDescriptors() = _allDescriptors() + override fun getAllDescriptors() = allDescriptors() private fun computeAllDescriptors(): List { val result = LinkedHashSet() diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragment.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragment.kt index ba194495b90..bc1f5a093a8 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragment.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragment.kt @@ -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" } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt index 10760f47faa..fed20d8a4fe 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticScope.kt @@ -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() } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt index 1108466025d..1e5e0621625 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/types/LazyJavaTypeResolver.kt @@ -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' in Java is a List in Kotlin, not a List @@ -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 } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/AbstractLazyType.kt b/core/descriptors/src/org/jetbrains/jet/lang/types/AbstractLazyType.kt index 620666ce556..d2535f3e9c7 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/AbstractLazyType.kt +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/AbstractLazyType.kt @@ -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 = _arguments() + private val arguments = storageManager.createLazyValue { computeArguments() } + override fun getArguments(): List = arguments() protected abstract fun computeArguments(): List - 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() + "" } return super.toString() diff --git a/idea/src/org/jetbrains/jet/plugin/formatter/SynteticKotlinBlock.kt b/idea/src/org/jetbrains/jet/plugin/formatter/SynteticKotlinBlock.kt index ec3b7e78481..30a407727cf 100644 --- a/idea/src/org/jetbrains/jet/plugin/formatter/SynteticKotlinBlock.kt +++ b/idea/src/org/jetbrains/jet/plugin/formatter/SynteticKotlinBlock.kt @@ -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, - 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, + 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 -> {