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

@@ -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

@@ -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 {
+        override fun getMemberScope(): JetScope = memberScope()
-            return _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

@@ -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
+    private val d = (parentScope?.depth ?: 0) + 1
-    val depth: Int get() = _d
+    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

@@ -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 viewProvider = super<JetFile>.getViewProvider() as SingleRootFileViewProvider
-    private var _myImports = HashSet<String>();
+    private var myImports = HashSet<String>();
 
     {
         getViewProvider().forceCachedPsi(this)
         init(TokenType.CODE_FRAGMENT, elementType)
-        if (_context != null) {
+        if (context != null) {
-            addImportsFromString(getImportsForElement(_context))
+            addImportsFromString(getImportsForElement(context))
         }
     }
 
-    private var _resolveScope: GlobalSearchScope? = null
+    private var resolveScope: GlobalSearchScope? = null
-    private var _thisType: PsiType? = null
+    private var thisType: PsiType? = null
-    private var _superType: PsiType? = null
+    private var superType: PsiType? = null
-    private var _exceptionHandler: JavaCodeFragment.ExceptionHandler? = 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.myImports = myImports
-        clone._viewProvider = SingleRootFileViewProvider(PsiManager.getInstance(_project), LightVirtualFile(getName(), JetFileType.INSTANCE, getText()), true)
+        clone.viewProvider = SingleRootFileViewProvider(PsiManager.getInstance(_project), LightVirtualFile(getName(), JetFileType.INSTANCE, getText()), true)
-        clone._viewProvider.forceCachedPsi(clone)
+        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

@@ -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

@@ -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,
+        private val jetScript: JetScript,
-        val _priority: Int
+        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

@@ -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

@@ -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

@@ -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())
+    private val modality = if (jClass.isAnnotationType())
-                                Modality.FINAL
+                               Modality.FINAL
-                            else Modality.convertFromFlags(jClass.isAbstract() || jClass.isInterface(), !jClass.isFinal())
+                           else Modality.convertFromFlags(jClass.isAbstract() || jClass.isInterface(), !jClass.isFinal())
 
-    private val _visibility = jClass.getVisibility()
+    private val visibility = jClass.getVisibility()
-    private val _isInner = jClass.getOuterClass() != null && !jClass.isStatic()
+    private val isInner = jClass.getOuterClass() != null && !jClass.isStatic()
 
-    override fun getKind() = _kind
+    override fun getKind() = kind
-    override fun getModality() = _modality
+    override fun getModality() = modality
-    override fun getVisibility() = _visibility
+    override fun getVisibility() = visibility
-    override fun isInner() = _isInner
+    override fun isInner() = isInner
 
-    private val _typeConstructor = c.storageManager.createLazyValue { LazyJavaClassTypeConstructor() }
+    private val typeConstructor = c.storageManager.createLazyValue { LazyJavaClassTypeConstructor() }
-    override fun getTypeConstructor(): TypeConstructor = _typeConstructor()
+    override fun getTypeConstructor(): TypeConstructor = typeConstructor()
 
-    private val _scopeForMemberLookup = LazyJavaClassMemberScope(c, this, jClass)
+    private val scopeForMemberLookup = LazyJavaClassMemberScope(c, this, jClass)
-    override fun getScopeForMemberLookup() = _scopeForMemberLookup
+    override fun getScopeForMemberLookup() = scopeForMemberLookup
 
-    private val _innerClassesScope = InnerClassesScopeWrapper(getScopeForMemberLookup())
+    private val innerClassesScope = InnerClassesScopeWrapper(getScopeForMemberLookup())
-    override fun getUnsubstitutedInnerClassesScope(): JetScope = _innerClassesScope
+    override fun getUnsubstitutedInnerClassesScope(): JetScope = innerClassesScope
 
-    private val _staticScope = LazyJavaStaticClassScope(c, jClass, this)
+    private val staticScope = LazyJavaStaticClassScope(c, jClass, this)
-    override fun getStaticScope(): JetScope = _staticScope
+    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) }
+    private val annotations = c.storageManager.createLazyValue { c.resolveAnnotations(jClass) }
-    override fun getAnnotations() = _annotations()
+    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 {
+        private val parameters = c.storageManager.createLazyValue {
-            jClass.getTypeParameters().map({
+            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

@@ -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

@@ -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

@@ -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

@@ -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_LOWER_BOUND -> return@l false
-                FLEXIBLE_UPPER_BOUND -> return@nullable true
+                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

@@ -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()}
+    private val typeConstructor = storageManager.createLazyValue { computeTypeConstructor() }
-    override fun getConstructor(): TypeConstructor = _typeConstructor()
+    override fun getConstructor(): TypeConstructor = typeConstructor()
 
     protected abstract fun computeTypeConstructor(): TypeConstructor
 
-    private val _arguments = storageManager.createLazyValue {computeArguments()}
+    private val arguments = storageManager.createLazyValue { computeArguments() }
-    override fun getArguments(): List<TypeProjection> = _arguments()
+    override fun getArguments(): List<TypeProjection> = arguments()
 
     protected abstract fun computeArguments(): List<TypeProjection>
 
-    private val _memberScope = storageManager.createLazyValue {computeMemberScope()}
+    private val memberScope = storageManager.createLazyValue { computeMemberScope() }
-    override fun getMemberScope() = _memberScope()
+    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

@@ -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 node: ASTNode,
-        private val _subBlocks: MutableList<Block>,
+        private val subBlocks: MutableList<Block>,
-        private val _alignment: Alignment?,
+        private val alignment: Alignment?,
-        private val _indent: Indent?,
+        private val indent: Indent?,
-        private val _wrap: Wrap?,
+        private val wrap: Wrap?,
-        private val spacingBuilder: KotlinSpacingBuilder) : ASTBlock {
+        private val spacingBuilder: KotlinSpacingBuilder
+) : ASTBlock {
 
-    private val _textRange = TextRange(
+    private val textRange = TextRange(
-            _subBlocks.first().getTextRange().getStartOffset(),
+            subBlocks.first().getTextRange().getStartOffset(),
-            _subBlocks.last().getTextRange().getEndOffset())
+            subBlocks.last().getTextRange().getEndOffset())
 
-    override fun getTextRange(): TextRange = _textRange
+    override fun getTextRange(): TextRange = textRange
-    override fun getSubBlocks() = _subBlocks
+    override fun getSubBlocks() = subBlocks
-    override fun getWrap() = _wrap
+    override fun getWrap() = wrap
-    override fun getIndent() = _indent
+    override fun getIndent() = indent
-    override fun getAlignment() = _alignment
+    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 -> {