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 <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
 }
 
 
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<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 {
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<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
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<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)
         }
     }
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<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()
 
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<JavaAnnotationArgument> = 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<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
 
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<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>()
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<Name>()
 }
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<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
     }
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<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()
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<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 -> {