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/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? {

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

@@ -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,
-        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)
         }