Rename stub classes: PsiJet*Stub(Impl) -> Kotlin*Stub(Impl)

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotation.java

@@ -18,18 +18,18 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.List;
 
-public class JetAnnotation extends JetElementImplStub<PsiJetPlaceHolderStub<JetAnnotation>> {
+public class JetAnnotation extends JetElementImplStub<KotlinPlaceHolderStub<JetAnnotation>> {
 
     public JetAnnotation(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetAnnotation(PsiJetPlaceHolderStub<JetAnnotation> stub) {
+    public JetAnnotation(KotlinPlaceHolderStub<JetAnnotation> stub) {
         super(stub, JetStubElementTypes.ANNOTATION);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetAnnotationEntry.java

@@ -20,18 +20,18 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetAnnotationEntryStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinAnnotationEntryStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetAnnotationEntry extends JetElementImplStub<PsiJetAnnotationEntryStub> implements JetCallElement {
+public class JetAnnotationEntry extends JetElementImplStub<KotlinAnnotationEntryStub> implements JetCallElement {
     public JetAnnotationEntry(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetAnnotationEntry(@NotNull PsiJetAnnotationEntryStub stub) {
+    public JetAnnotationEntry(@NotNull KotlinAnnotationEntryStub stub) {
         super(stub, JetStubElementTypes.ANNOTATION_ENTRY);
     }
 
@@ -57,7 +57,7 @@ public class JetAnnotationEntry extends JetElementImplStub<PsiJetAnnotationEntry
 
     @Override
     public JetValueArgumentList getValueArgumentList() {
-        PsiJetAnnotationEntryStub stub = getStub();
+        KotlinAnnotationEntryStub stub = getStub();
         if (stub != null && !stub.hasValueArguments()) {
             return null;
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClass.java

@@ -28,7 +28,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
 import org.jetbrains.jet.lang.psi.addRemoveModifier.AddRemoveModifierPackage;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetClassStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinClassStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lexer.JetModifierKeywordToken;
@@ -38,13 +38,13 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-public class JetClass extends JetTypeParameterListOwnerStub<PsiJetClassStub> implements JetClassOrObject {
+public class JetClass extends JetTypeParameterListOwnerStub<KotlinClassStub> implements JetClassOrObject {
 
     public JetClass(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetClass(@NotNull PsiJetClassStub stub) {
+    public JetClass(@NotNull KotlinClassStub stub) {
         super(stub, JetStubElementTypes.CLASS);
     }
 
@@ -156,7 +156,7 @@ public class JetClass extends JetTypeParameterListOwnerStub<PsiJetClassStub> imp
     }
 
     public boolean isTrait() {
-        PsiJetClassStub stub = getStub();
+        KotlinClassStub stub = getStub();
         if (stub != null) {
             return stub.isTrait();
         }
@@ -196,7 +196,7 @@ public class JetClass extends JetTypeParameterListOwnerStub<PsiJetClassStub> imp
 
     @Nullable
     private String getQualifiedName() {
-        PsiJetClassStub stub = getStub();
+        KotlinClassStub stub = getStub();
         if (stub != null) {
             FqName fqName = stub.getFqName();
             return fqName == null ? null : fqName.asString();
@@ -230,7 +230,7 @@ public class JetClass extends JetTypeParameterListOwnerStub<PsiJetClassStub> imp
 
     @Override
     public boolean isLocal() {
-        PsiJetClassStub stub = getStub();
+        KotlinClassStub stub = getStub();
         if (stub != null) {
             return stub.isLocal();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassBody.java

@@ -22,7 +22,7 @@ import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
@@ -31,13 +31,13 @@ import java.util.List;
 
 import static org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes.*;
 
-public class JetClassBody extends JetElementImplStub<PsiJetPlaceHolderStub<JetClassBody>> implements JetDeclarationContainer {
+public class JetClassBody extends JetElementImplStub<KotlinPlaceHolderStub<JetClassBody>> implements JetDeclarationContainer {
 
     public JetClassBody(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetClassBody(@NotNull PsiJetPlaceHolderStub<JetClassBody> stub) {
+    public JetClassBody(@NotNull KotlinPlaceHolderStub<JetClassBody> stub) {
         super(stub, CLASS_BODY);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassInitializer.java

@@ -20,15 +20,15 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class JetClassInitializer extends JetDeclarationStub<PsiJetPlaceHolderStub<JetClassInitializer>> implements JetStatementExpression {
+public class JetClassInitializer extends JetDeclarationStub<KotlinPlaceHolderStub<JetClassInitializer>> implements JetStatementExpression {
     public JetClassInitializer(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetClassInitializer(@NotNull PsiJetPlaceHolderStub<JetClassInitializer> stub) {
+    public JetClassInitializer(@NotNull KotlinPlaceHolderStub<JetClassInitializer> stub) {
         super(stub, JetStubElementTypes.ANONYMOUS_INITIALIZER);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetClassObject.java

@@ -20,16 +20,16 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
-public class JetClassObject extends JetDeclarationStub<PsiJetPlaceHolderStub<JetClassObject>> implements JetStatementExpression {
+public class JetClassObject extends JetDeclarationStub<KotlinPlaceHolderStub<JetClassObject>> implements JetStatementExpression {
     public JetClassObject(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetClassObject(@NotNull PsiJetPlaceHolderStub<JetClassObject> stub) {
+    public JetClassObject(@NotNull KotlinPlaceHolderStub<JetClassObject> stub) {
         super(stub, JetStubElementTypes.CLASS_OBJECT);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetConstructorCalleeExpression.java

@@ -19,15 +19,15 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class JetConstructorCalleeExpression extends JetExpressionImplStub<PsiJetPlaceHolderStub<JetConstructorCalleeExpression>> {
+public class JetConstructorCalleeExpression extends JetExpressionImplStub<KotlinPlaceHolderStub<JetConstructorCalleeExpression>> {
     public JetConstructorCalleeExpression(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetConstructorCalleeExpression(@NotNull PsiJetPlaceHolderStub<JetConstructorCalleeExpression> stub) {
+    public JetConstructorCalleeExpression(@NotNull KotlinPlaceHolderStub<JetConstructorCalleeExpression> stub) {
         super(stub, JetStubElementTypes.CONSTRUCTOR_CALLEE);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDeclarationModifierList.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetModifierListStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinModifierListStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 public class JetDeclarationModifierList extends JetModifierList {
@@ -26,7 +26,7 @@ public class JetDeclarationModifierList extends JetModifierList {
         super(node);
     }
 
-    public JetDeclarationModifierList(@NotNull PsiJetModifierListStub stub) {
+    public JetDeclarationModifierList(@NotNull KotlinModifierListStub stub) {
         super(stub, JetStubElementTypes.MODIFIER_LIST);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifier.java

@@ -21,10 +21,10 @@ import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.util.ArrayFactory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class JetDelegationSpecifier extends JetElementImplStub<PsiJetPlaceHolderStub<? extends JetDelegationSpecifier>> {
+public class JetDelegationSpecifier extends JetElementImplStub<KotlinPlaceHolderStub<? extends JetDelegationSpecifier>> {
 
     private static final JetDelegationSpecifier[] EMPTY_ARRAY = new JetDelegationSpecifier[0];
 
@@ -41,7 +41,7 @@ public class JetDelegationSpecifier extends JetElementImplStub<PsiJetPlaceHolder
     }
 
     public JetDelegationSpecifier(
-            @NotNull PsiJetPlaceHolderStub<? extends JetDelegationSpecifier> stub,
+            @NotNull KotlinPlaceHolderStub<? extends JetDelegationSpecifier> stub,
             @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegationSpecifierList.java

@@ -18,18 +18,18 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.Arrays;
 import java.util.List;
 
-public class JetDelegationSpecifierList extends JetElementImplStub<PsiJetPlaceHolderStub<JetDelegationSpecifierList>> {
+public class JetDelegationSpecifierList extends JetElementImplStub<KotlinPlaceHolderStub<JetDelegationSpecifierList>> {
     public JetDelegationSpecifierList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetDelegationSpecifierList(@NotNull PsiJetPlaceHolderStub<JetDelegationSpecifierList> stub) {
+    public JetDelegationSpecifierList(@NotNull KotlinPlaceHolderStub<JetDelegationSpecifierList> stub) {
         super(stub, JetStubElementTypes.DELEGATION_SPECIFIER_LIST);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorByExpressionSpecifier.java

@@ -19,7 +19,7 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 public class JetDelegatorByExpressionSpecifier extends JetDelegationSpecifier {
@@ -27,7 +27,7 @@ public class JetDelegatorByExpressionSpecifier extends JetDelegationSpecifier {
         super(node);
     }
 
-    public JetDelegatorByExpressionSpecifier(@NotNull PsiJetPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
+    public JetDelegatorByExpressionSpecifier(@NotNull KotlinPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
         super(stub, JetStubElementTypes.DELEGATOR_BY);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperCall.java

@@ -20,7 +20,7 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.Collections;
@@ -31,7 +31,7 @@ public class JetDelegatorToSuperCall extends JetDelegationSpecifier implements J
         super(node);
     }
 
-    public JetDelegatorToSuperCall(@NotNull PsiJetPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
+    public JetDelegatorToSuperCall(@NotNull KotlinPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
         super(stub, JetStubElementTypes.DELEGATOR_SUPER_CALL);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToSuperClass.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 public class JetDelegatorToSuperClass extends JetDelegationSpecifier {
@@ -26,7 +26,7 @@ public class JetDelegatorToSuperClass extends JetDelegationSpecifier {
         super(node);
     }
 
-    public JetDelegatorToSuperClass(@NotNull PsiJetPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
+    public JetDelegatorToSuperClass(@NotNull KotlinPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
         super(stub, JetStubElementTypes.DELEGATOR_SUPER_CLASS);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDelegatorToThisCall.java

@@ -20,7 +20,7 @@ import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.Collections;
@@ -32,7 +32,7 @@ public class JetDelegatorToThisCall extends JetDelegationSpecifier implements Je
         super(node);
     }
 
-    public JetDelegatorToThisCall(@NotNull PsiJetPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
+    public JetDelegatorToThisCall(@NotNull KotlinPlaceHolderStub<? extends JetDelegationSpecifier> stub) {
         super(stub, JetStubElementTypes.THIS_CALL);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetDotQualifiedExpression.java

@@ -20,13 +20,13 @@ import com.intellij.lang.ASTNode;
 import com.intellij.openapi.diagnostic.Logger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetToken;
 
 import static org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes.INSIDE_DIRECTIVE_EXPRESSIONS;
 
-public class JetDotQualifiedExpression extends JetExpressionImplStub<PsiJetPlaceHolderStub<JetDotQualifiedExpression>>
+public class JetDotQualifiedExpression extends JetExpressionImplStub<KotlinPlaceHolderStub<JetDotQualifiedExpression>>
         implements JetQualifiedExpression {
 
     private static final Logger LOG = Logger.getInstance(JetDotQualifiedExpression.class);
@@ -35,7 +35,7 @@ public class JetDotQualifiedExpression extends JetExpressionImplStub<PsiJetPlace
         super(node);
     }
 
-    public JetDotQualifiedExpression(@NotNull PsiJetPlaceHolderStub<JetDotQualifiedExpression> stub) {
+    public JetDotQualifiedExpression(@NotNull KotlinPlaceHolderStub<JetDotQualifiedExpression> stub) {
         super(stub, JetStubElementTypes.DOT_QUALIFIED_EXPRESSION);
     }
 
@@ -47,7 +47,7 @@ public class JetDotQualifiedExpression extends JetExpressionImplStub<PsiJetPlace
     @NotNull
     @Override
     public JetExpression getReceiverExpression() {
-        PsiJetPlaceHolderStub<JetDotQualifiedExpression> stub = getStub();
+        KotlinPlaceHolderStub<JetDotQualifiedExpression> stub = getStub();
         if (stub != null) {
             JetExpression[] childExpressionsByStub = getChildExpressionsByStub(stub);
             if (childExpressionsByStub != null) {
@@ -60,7 +60,7 @@ public class JetDotQualifiedExpression extends JetExpressionImplStub<PsiJetPlace
     @Nullable
     @Override
     public JetExpression getSelectorExpression() {
-        PsiJetPlaceHolderStub<JetDotQualifiedExpression> stub = getStub();
+        KotlinPlaceHolderStub<JetDotQualifiedExpression> stub = getStub();
         if (stub != null) {
             JetExpression[] childExpressionsByStub = getChildExpressionsByStub(stub);
             if (childExpressionsByStub != null && childExpressionsByStub.length == 2) {
@@ -72,7 +72,7 @@ public class JetDotQualifiedExpression extends JetExpressionImplStub<PsiJetPlace
 
 
     @Nullable
-    private JetExpression[] getChildExpressionsByStub(@NotNull PsiJetPlaceHolderStub<JetDotQualifiedExpression> stub) {
+    private JetExpression[] getChildExpressionsByStub(@NotNull KotlinPlaceHolderStub<JetDotQualifiedExpression> stub) {
         if (stub.getParentStubOfType(JetImportDirective.class) == null && stub.getParentStubOfType(JetPackageDirective.class) == null) {
             LOG.error("JetDotQualifiedExpression should only have stubs inside import or package directives.\n " +
                       "Stubs were created for:\n " + getText() +

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetEnumEntry.java

@@ -22,7 +22,7 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetClassStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinClassStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.Collections;
@@ -33,13 +33,13 @@ public class JetEnumEntry extends JetClass {
         super(node);
     }
 
-    public JetEnumEntry(@NotNull PsiJetClassStub stub) {
+    public JetEnumEntry(@NotNull KotlinClassStub stub) {
         super(stub);
     }
 
     @Override
     public String getName() {
-        PsiJetClassStub classStub = getStub();
+        KotlinClassStub classStub = getStub();
         if (classStub != null) {
             return classStub.getName();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFile.java

@@ -29,7 +29,7 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetFileStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinFileStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetPlaceHolderStubElementType;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -72,7 +72,7 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
     @NotNull
     @Override
     public List<JetDeclaration> getDeclarations() {
-        PsiJetFileStub stub = getStub();
+        KotlinFileStub stub = getStub();
         if (stub != null) {
             return Arrays.asList(stub.getChildrenByType(JetStubElementTypes.DECLARATION_TYPES, JetDeclaration.ARRAY_FACTORY));
         }
@@ -94,7 +94,7 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
             @NotNull JetPlaceHolderStubElementType<T> elementType,
             @NotNull Class<T> elementClass
     ) {
-        PsiJetFileStub stub = getStub();
+        KotlinFileStub stub = getStub();
         if (stub != null) {
             StubElement<T> importListStub = stub.findChildStubByType(elementType);
             return importListStub != null ? importListStub.getPsi() : null;
@@ -121,7 +121,7 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
     // scripts have no package directive, all other files must have package directives
     @Nullable
     public JetPackageDirective getPackageDirective() {
-        PsiJetFileStub stub = getStub();
+        KotlinFileStub stub = getStub();
         if (stub != null) {
             StubElement<JetPackageDirective> packageDirectiveStub = stub.findChildStubByType(JetStubElementTypes.PACKAGE_DIRECTIVE);
             return packageDirectiveStub != null ? packageDirectiveStub.getPsi() : null;
@@ -139,7 +139,7 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
 
     @NotNull
     public FqName getPackageFqName() {
-        PsiJetFileStub stub = getStub();
+        KotlinFileStub stub = getStub();
         if (stub != null) {
             return stub.getPackageFqName();
         }
@@ -157,8 +157,8 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
 
     @Override
     @Nullable
-    public PsiJetFileStub getStub() {
+    public KotlinFileStub getStub() {
-        return (PsiJetFileStub) super.getStub();
+        return (KotlinFileStub) super.getStub();
     }
 
     @NotNull
@@ -177,7 +177,7 @@ public class JetFile extends PsiFileBase implements JetDeclarationContainer, Jet
     }
 
     public boolean isScript() {
-        PsiJetFileStub stub = getStub();
+        KotlinFileStub stub = getStub();
         if (stub != null) {
             return stub.isScript();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFileAnnotationList.java

@@ -20,18 +20,18 @@ import com.intellij.lang.ASTNode;
 import kotlin.Function1;
 import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.List;
 
-public class JetFileAnnotationList extends JetElementImplStub<PsiJetPlaceHolderStub<JetFileAnnotationList>> {
+public class JetFileAnnotationList extends JetElementImplStub<KotlinPlaceHolderStub<JetFileAnnotationList>> {
 
     public JetFileAnnotationList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetFileAnnotationList(@NotNull PsiJetPlaceHolderStub<JetFileAnnotationList> stub) {
+    public JetFileAnnotationList(@NotNull KotlinPlaceHolderStub<JetFileAnnotationList> stub) {
         super(stub, JetStubElementTypes.FILE_ANNOTATION_LIST);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionType.java

@@ -20,7 +20,7 @@ import com.google.common.collect.Lists;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetToken;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -29,7 +29,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-public class JetFunctionType extends JetElementImplStub<PsiJetPlaceHolderStub<JetFunctionType>> implements JetTypeElement {
+public class JetFunctionType extends JetElementImplStub<KotlinPlaceHolderStub<JetFunctionType>> implements JetTypeElement {
 
     public static final JetToken RETURN_TYPE_SEPARATOR = JetTokens.ARROW;
 
@@ -37,7 +37,7 @@ public class JetFunctionType extends JetElementImplStub<PsiJetPlaceHolderStub<Je
         super(node);
     }
 
-    public JetFunctionType(@NotNull PsiJetPlaceHolderStub<JetFunctionType> stub) {
+    public JetFunctionType(@NotNull KotlinPlaceHolderStub<JetFunctionType> stub) {
         super(stub, JetStubElementTypes.FUNCTION_TYPE);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetFunctionTypeReceiver.java

@@ -18,15 +18,15 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class JetFunctionTypeReceiver extends JetElementImplStub<PsiJetPlaceHolderStub<JetFunctionTypeReceiver>> {
+public class JetFunctionTypeReceiver extends JetElementImplStub<KotlinPlaceHolderStub<JetFunctionTypeReceiver>> {
     public JetFunctionTypeReceiver(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetFunctionTypeReceiver(@NotNull PsiJetPlaceHolderStub<JetFunctionTypeReceiver> stub) {
+    public JetFunctionTypeReceiver(@NotNull KotlinPlaceHolderStub<JetFunctionTypeReceiver> stub) {
         super(stub, JetStubElementTypes.FUNCTION_TYPE_RECEIVER);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportDirective.java

@@ -21,20 +21,20 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetImportDirectiveStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinImportDirectiveStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lexer.JetTokens;
 
-public class JetImportDirective extends JetElementImplStub<PsiJetImportDirectiveStub> {
+public class JetImportDirective extends JetElementImplStub<KotlinImportDirectiveStub> {
 
     public JetImportDirective(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetImportDirective(@NotNull PsiJetImportDirectiveStub stub) {
+    public JetImportDirective(@NotNull KotlinImportDirectiveStub stub) {
         super(stub, JetStubElementTypes.IMPORT_DIRECTIVE);
     }
 
@@ -44,7 +44,7 @@ public class JetImportDirective extends JetElementImplStub<PsiJetImportDirective
     }
 
     public boolean isAbsoluteInRootPackage() {
-        PsiJetImportDirectiveStub stub = getStub();
+        KotlinImportDirectiveStub stub = getStub();
         if (stub != null) {
             return stub.isAbsoluteInRootPackage();
         }
@@ -78,7 +78,7 @@ public class JetImportDirective extends JetElementImplStub<PsiJetImportDirective
 
     @Nullable
     public String getAliasName() {
-        PsiJetImportDirectiveStub stub = getStub();
+        KotlinImportDirectiveStub stub = getStub();
         if (stub != null) {
             return stub.getAliasName();
         }
@@ -90,7 +90,7 @@ public class JetImportDirective extends JetElementImplStub<PsiJetImportDirective
     }
 
     public boolean isAllUnder() {
-        PsiJetImportDirectiveStub stub = getStub();
+        KotlinImportDirectiveStub stub = getStub();
         if (stub != null) {
             return stub.isAllUnder();
         }
@@ -117,7 +117,7 @@ public class JetImportDirective extends JetElementImplStub<PsiJetImportDirective
     }
 
     public boolean isValidImport() {
-        PsiJetImportDirectiveStub stub = getStub();
+        KotlinImportDirectiveStub stub = getStub();
         if (stub != null) {
             return stub.isValid();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetImportList.java

@@ -18,18 +18,18 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.List;
 
-public class JetImportList extends JetElementImplStub<PsiJetPlaceHolderStub<JetImportList>> {
+public class JetImportList extends JetElementImplStub<KotlinPlaceHolderStub<JetImportList>> {
 
     public JetImportList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetImportList(@NotNull PsiJetPlaceHolderStub<JetImportList> stub) {
+    public JetImportList(@NotNull KotlinPlaceHolderStub<JetImportList> stub) {
         super(stub, JetStubElementTypes.IMPORT_LIST);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetInitializerList.java

@@ -17,21 +17,19 @@
 package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
-import com.intellij.psi.stubs.IStubElementType;
-import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.Arrays;
 import java.util.List;
 
-public class JetInitializerList extends JetElementImplStub<PsiJetPlaceHolderStub<JetInitializerList>> {
+public class JetInitializerList extends JetElementImplStub<KotlinPlaceHolderStub<JetInitializerList>> {
     public JetInitializerList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetInitializerList(@NotNull PsiJetPlaceHolderStub<JetInitializerList> stub) {
+    public JetInitializerList(@NotNull KotlinPlaceHolderStub<JetInitializerList> stub) {
         super(stub, JetStubElementTypes.INITIALIZER_LIST);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetModifierList.java

@@ -22,7 +22,7 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.stubs.IStubElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetModifierListStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinModifierListStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetToken;
@@ -31,9 +31,9 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-public abstract class JetModifierList extends JetElementImplStub<PsiJetModifierListStub> {
+public abstract class JetModifierList extends JetElementImplStub<KotlinModifierListStub> {
 
-    public JetModifierList(@NotNull PsiJetModifierListStub stub, @NotNull IStubElementType nodeType) {
+    public JetModifierList(@NotNull KotlinModifierListStub stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }
 
@@ -63,7 +63,7 @@ public abstract class JetModifierList extends JetElementImplStub<PsiJetModifierL
     }
 
     public boolean hasModifier(@NotNull JetModifierKeywordToken token) {
-        PsiJetModifierListStub stub = getStub();
+        KotlinModifierListStub stub = getStub();
         if (stub != null) {
             return stub.hasModifier(token);
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNameReferenceExpression.java

@@ -22,14 +22,14 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.tree.TokenSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetNameReferenceExpressionStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinNameReferenceExpressionStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import static org.jetbrains.jet.lexer.JetTokens.*;
 
-public class JetNameReferenceExpression extends JetExpressionImplStub<PsiJetNameReferenceExpressionStub> implements JetSimpleNameExpression {
+public class JetNameReferenceExpression extends JetExpressionImplStub<KotlinNameReferenceExpressionStub> implements JetSimpleNameExpression {
 
     private static final TokenSet NAME_REFERENCE_EXPRESSIONS = TokenSet.create(IDENTIFIER, FIELD_IDENTIFIER, THIS_KEYWORD, SUPER_KEYWORD);
 
@@ -37,14 +37,14 @@ public class JetNameReferenceExpression extends JetExpressionImplStub<PsiJetName
         super(node);
     }
 
-    public JetNameReferenceExpression(@NotNull PsiJetNameReferenceExpressionStub stub) {
+    public JetNameReferenceExpression(@NotNull KotlinNameReferenceExpressionStub stub) {
         super(stub, JetStubElementTypes.REFERENCE_EXPRESSION);
     }
 
     @Override
     @NotNull
     public String getReferencedName() {
-        PsiJetNameReferenceExpressionStub stub = getStub();
+        KotlinNameReferenceExpressionStub stub = getStub();
         if (stub != null) {
             return stub.getReferencedName();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedDeclarationStub.java

@@ -26,14 +26,14 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetStubWithFqName;
+import org.jetbrains.jet.lang.psi.stubs.KotlinStubWithFqName;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import static org.jetbrains.jet.lang.psi.PsiPackage.JetPsiFactory;
 
-abstract class JetNamedDeclarationStub<T extends PsiJetStubWithFqName> extends JetDeclarationStub<T> implements JetNamedDeclaration {
+abstract class JetNamedDeclarationStub<T extends KotlinStubWithFqName> extends JetDeclarationStub<T> implements JetNamedDeclaration {
     public JetNamedDeclarationStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamedFunction.java

@@ -25,7 +25,7 @@ import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetFunctionStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinFunctionStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.psi.typeRefHelpers.TypeRefHelpersPackage;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -33,13 +33,13 @@ import org.jetbrains.jet.lexer.JetTokens;
 import java.util.Collections;
 import java.util.List;
 
-public class JetNamedFunction extends JetTypeParameterListOwnerStub<PsiJetFunctionStub>
+public class JetNamedFunction extends JetTypeParameterListOwnerStub<KotlinFunctionStub>
         implements JetFunction, JetWithExpressionInitializer, PsiModifiableCodeBlock {
     public JetNamedFunction(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetNamedFunction(@NotNull PsiJetFunctionStub stub) {
+    public JetNamedFunction(@NotNull KotlinFunctionStub stub) {
         super(stub, JetStubElementTypes.FUNCTION);
     }
 
@@ -49,7 +49,7 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<PsiJetFuncti
     }
 
     public boolean hasTypeParameterListBeforeFunctionName() {
-        PsiJetFunctionStub stub = getStub();
+        KotlinFunctionStub stub = getStub();
         if (stub != null) {
             return stub.hasTypeParameterListBeforeFunctionName();
         }
@@ -70,7 +70,7 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<PsiJetFuncti
 
     @Override
     public boolean hasBlockBody() {
-        PsiJetFunctionStub stub = getStub();
+        KotlinFunctionStub stub = getStub();
         if (stub != null) {
             return stub.hasBlockBody();
         }
@@ -119,7 +119,7 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<PsiJetFuncti
 
     @Override
     public boolean hasBody() {
-        PsiJetFunctionStub stub = getStub();
+        KotlinFunctionStub stub = getStub();
         if (stub != null) {
             return stub.hasBody();
         }
@@ -134,7 +134,7 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<PsiJetFuncti
     @Override
     @Nullable
     public JetTypeReference getReceiverTypeReference() {
-        PsiJetFunctionStub stub = getStub();
+        KotlinFunctionStub stub = getStub();
         if (stub != null) {
             if (!stub.isExtension()) {
                 return null;
@@ -168,7 +168,7 @@ public class JetNamedFunction extends JetTypeParameterListOwnerStub<PsiJetFuncti
     @Override
     @Nullable
     public JetTypeReference getTypeReference() {
-        PsiJetFunctionStub stub = getStub();
+        KotlinFunctionStub stub = getStub();
         if (stub != null) {
             List<JetTypeReference> typeReferences = getStubOrPsiChildrenAsList(JetStubElementTypes.TYPE_REFERENCE);
             int returnTypeIndex = stub.isExtension() ? 1 : 0;

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNullableType.java

@@ -19,19 +19,19 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetNullableType extends JetElementImplStub<PsiJetPlaceHolderStub<JetNullableType>> implements JetTypeElement {
+public class JetNullableType extends JetElementImplStub<KotlinPlaceHolderStub<JetNullableType>> implements JetTypeElement {
     public JetNullableType(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetNullableType(@NotNull PsiJetPlaceHolderStub<JetNullableType> stub) {
+    public JetNullableType(@NotNull KotlinPlaceHolderStub<JetNullableType> stub) {
         super(stub, JetStubElementTypes.NULLABLE_TYPE);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetObjectDeclaration.java

@@ -25,7 +25,7 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetObjectStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinObjectStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -33,18 +33,18 @@ import org.jetbrains.jet.lexer.JetTokens;
 import java.util.Collections;
 import java.util.List;
 
-public class JetObjectDeclaration extends JetNamedDeclarationStub<PsiJetObjectStub> implements JetClassOrObject  {
+public class JetObjectDeclaration extends JetNamedDeclarationStub<KotlinObjectStub> implements JetClassOrObject  {
     public JetObjectDeclaration(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetObjectDeclaration(@NotNull PsiJetObjectStub stub) {
+    public JetObjectDeclaration(@NotNull KotlinObjectStub stub) {
         super(stub, JetStubElementTypes.OBJECT_DECLARATION);
     }
 
     @Override
     public String getName() {
-        PsiJetObjectStub stub = getStub();
+        KotlinObjectStub stub = getStub();
         if (stub != null) {
             return stub.getName();
         }
@@ -55,7 +55,7 @@ public class JetObjectDeclaration extends JetNamedDeclarationStub<PsiJetObjectSt
 
     @Override
     public boolean isTopLevel() {
-        PsiJetObjectStub stub = getStub();
+        KotlinObjectStub stub = getStub();
         if (stub != null) {
             return stub.isTopLevel();
         }
@@ -93,7 +93,7 @@ public class JetObjectDeclaration extends JetNamedDeclarationStub<PsiJetObjectSt
     }
 
     public boolean isClassObject() {
-        PsiJetObjectStub stub = getStub();
+        KotlinObjectStub stub = getStub();
         if (stub != null) {
             return stub.isClassObject();
         }
@@ -149,7 +149,7 @@ public class JetObjectDeclaration extends JetNamedDeclarationStub<PsiJetObjectSt
 
     @Override
     public boolean isLocal() {
-        PsiJetObjectStub stub = getStub();
+        KotlinObjectStub stub = getStub();
         if (stub != null) {
             return stub.isLocal();
         }
@@ -171,7 +171,7 @@ public class JetObjectDeclaration extends JetNamedDeclarationStub<PsiJetObjectSt
     }
 
     public boolean isObjectLiteral() {
-        PsiJetObjectStub stub = getStub();
+        KotlinObjectStub stub = getStub();
         if (stub != null) {
             return stub.isObjectLiteral();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPackageDirective.java

@@ -22,7 +22,7 @@ import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -31,14 +31,14 @@ import org.jetbrains.jet.lang.resolve.name.SpecialNames;
 import java.util.Collections;
 import java.util.List;
 
-public class JetPackageDirective extends JetModifierListOwnerStub<PsiJetPlaceHolderStub<JetPackageDirective>> implements JetReferenceExpression {
+public class JetPackageDirective extends JetModifierListOwnerStub<KotlinPlaceHolderStub<JetPackageDirective>> implements JetReferenceExpression {
     private String qualifiedNameCache = null;
 
     public JetPackageDirective(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetPackageDirective(@NotNull PsiJetPlaceHolderStub<JetPackageDirective> stub) {
+    public JetPackageDirective(@NotNull KotlinPlaceHolderStub<JetPackageDirective> stub) {
         super(stub, JetStubElementTypes.PACKAGE_DIRECTIVE);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameter.java

@@ -22,7 +22,7 @@ import com.intellij.navigation.ItemPresentationProviders;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetParameterStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinParameterStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.psi.typeRefHelpers.TypeRefHelpersPackage;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -30,13 +30,13 @@ import org.jetbrains.jet.lexer.JetTokens;
 import java.util.Collections;
 import java.util.List;
 
-public class JetParameter extends JetNamedDeclarationStub<PsiJetParameterStub> implements JetCallableDeclaration {
+public class JetParameter extends JetNamedDeclarationStub<KotlinParameterStub> implements JetCallableDeclaration {
 
     public JetParameter(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetParameter(@NotNull PsiJetParameterStub stub) {
+    public JetParameter(@NotNull KotlinParameterStub stub) {
         super(stub, JetStubElementTypes.VALUE_PARAMETER);
     }
 
@@ -64,7 +64,7 @@ public class JetParameter extends JetNamedDeclarationStub<PsiJetParameterStub> i
     }
 
     public boolean hasDefaultValue() {
-        PsiJetParameterStub stub = getStub();
+        KotlinParameterStub stub = getStub();
         if (stub != null) {
             return stub.hasDefaultValue();
         }
@@ -73,7 +73,7 @@ public class JetParameter extends JetNamedDeclarationStub<PsiJetParameterStub> i
 
     @Nullable
     public JetExpression getDefaultValue() {
-        PsiJetParameterStub stub = getStub();
+        KotlinParameterStub stub = getStub();
         if (stub != null && !stub.hasDefaultValue()) {
             return null;
         }
@@ -91,7 +91,7 @@ public class JetParameter extends JetNamedDeclarationStub<PsiJetParameterStub> i
     }
 
     public boolean isMutable() {
-        PsiJetParameterStub stub = getStub();
+        KotlinParameterStub stub = getStub();
         if (stub != null) {
             return stub.isMutable();
         }
@@ -105,7 +105,7 @@ public class JetParameter extends JetNamedDeclarationStub<PsiJetParameterStub> i
     }
 
     public boolean hasValOrVarNode() {
-        PsiJetParameterStub stub = getStub();
+        KotlinParameterStub stub = getStub();
         if (stub != null) {
             return stub.hasValOrValNode();
         }
@@ -114,7 +114,7 @@ public class JetParameter extends JetNamedDeclarationStub<PsiJetParameterStub> i
 
     @Nullable
     public ASTNode getValOrVarNode() {
-        PsiJetParameterStub stub = getStub();
+        KotlinParameterStub stub = getStub();
         if (stub != null && !stub.hasValOrValNode()) {
             return null;
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetParameterList.java

@@ -18,17 +18,17 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.List;
 
-public class JetParameterList extends JetElementImplStub<PsiJetPlaceHolderStub<JetParameterList>> {
+public class JetParameterList extends JetElementImplStub<KotlinPlaceHolderStub<JetParameterList>> {
     public JetParameterList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetParameterList(@NotNull PsiJetPlaceHolderStub<JetParameterList> stub) {
+    public JetParameterList(@NotNull KotlinPlaceHolderStub<JetParameterList> stub) {
         super(stub, JetStubElementTypes.VALUE_PARAMETER_LIST);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPrimaryConstructorModifierList.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetModifierListStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinModifierListStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 public class JetPrimaryConstructorModifierList extends JetModifierList {
@@ -26,7 +26,7 @@ public class JetPrimaryConstructorModifierList extends JetModifierList {
         super(node);
     }
 
-    public JetPrimaryConstructorModifierList(@NotNull PsiJetModifierListStub stub) {
+    public JetPrimaryConstructorModifierList(@NotNull KotlinModifierListStub stub) {
         super(stub, JetStubElementTypes.PRIMARY_CONSTRUCTOR_MODIFIER_LIST);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetProperty.java

@@ -28,7 +28,7 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetNodeTypes;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPropertyStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPropertyStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.psi.typeRefHelpers.TypeRefHelpersPackage;
 import org.jetbrains.jet.lexer.JetTokens;
@@ -38,7 +38,7 @@ import java.util.List;
 import static org.jetbrains.jet.JetNodeTypes.PROPERTY_DELEGATE;
 import static org.jetbrains.jet.lexer.JetTokens.*;
 
-public class JetProperty extends JetTypeParameterListOwnerStub<PsiJetPropertyStub>
+public class JetProperty extends JetTypeParameterListOwnerStub<KotlinPropertyStub>
         implements JetVariableDeclaration, PsiModifiableCodeBlock {
 
     private static final Logger LOG = Logger.getInstance(JetProperty.class);
@@ -47,7 +47,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<PsiJetPropertyStu
         super(node);
     }
 
-    public JetProperty(@NotNull PsiJetPropertyStub stub) {
+    public JetProperty(@NotNull KotlinPropertyStub stub) {
         super(stub, JetStubElementTypes.PROPERTY);
     }
 
@@ -58,7 +58,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<PsiJetPropertyStu
 
     @Override
     public boolean isVar() {
-        PsiJetPropertyStub stub = getStub();
+        KotlinPropertyStub stub = getStub();
         if (stub != null) {
             return stub.isVar();
         }
@@ -72,7 +72,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<PsiJetPropertyStu
     }
 
     public boolean isTopLevel() {
-        PsiJetPropertyStub stub = getStub();
+        KotlinPropertyStub stub = getStub();
         if (stub != null) {
             return stub.isTopLevel();
         }
@@ -89,7 +89,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<PsiJetPropertyStu
     @Override
     @Nullable
     public JetTypeReference getReceiverTypeReference() {
-        PsiJetPropertyStub stub = getStub();
+        KotlinPropertyStub stub = getStub();
         if (stub != null) {
             if (!stub.hasReceiverTypeRef()) {
                 return null;
@@ -120,7 +120,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<PsiJetPropertyStu
     @Override
     @Nullable
     public JetTypeReference getTypeReference() {
-        PsiJetPropertyStub stub = getStub();
+        KotlinPropertyStub stub = getStub();
         if (stub != null) {
             if (!stub.hasReturnTypeRef()) {
                 return null;
@@ -174,7 +174,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<PsiJetPropertyStu
     }
 
     public boolean hasDelegate() {
-        PsiJetPropertyStub stub = getStub();
+        KotlinPropertyStub stub = getStub();
         if (stub != null) {
             return stub.hasDelegate();
         }
@@ -187,7 +187,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<PsiJetPropertyStu
     }
 
     public boolean hasDelegateExpression() {
-        PsiJetPropertyStub stub = getStub();
+        KotlinPropertyStub stub = getStub();
         if (stub != null) {
             return stub.hasDelegateExpression();
         }
@@ -205,7 +205,7 @@ public class JetProperty extends JetTypeParameterListOwnerStub<PsiJetPropertyStu
 
     @Override
     public boolean hasInitializer() {
-        PsiJetPropertyStub stub = getStub();
+        KotlinPropertyStub stub = getStub();
         if (stub != null) {
             return stub.hasInitializer();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPropertyAccessor.java

@@ -21,20 +21,20 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPropertyAccessorStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPropertyAccessorStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetPropertyAccessor extends JetDeclarationStub<PsiJetPropertyAccessorStub>
+public class JetPropertyAccessor extends JetDeclarationStub<KotlinPropertyAccessorStub>
         implements JetDeclarationWithBody, JetModifierListOwner, JetWithExpressionInitializer {
     public JetPropertyAccessor(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetPropertyAccessor(@NotNull PsiJetPropertyAccessorStub stub) {
+    public JetPropertyAccessor(@NotNull KotlinPropertyAccessorStub stub) {
         super(stub, JetStubElementTypes.PROPERTY_ACCESSOR);
     }
 
@@ -44,7 +44,7 @@ public class JetPropertyAccessor extends JetDeclarationStub<PsiJetPropertyAccess
     }
 
     public boolean isSetter() {
-        PsiJetPropertyAccessorStub stub = getStub();
+        KotlinPropertyAccessorStub stub = getStub();
         if (stub != null) {
             return !stub.isGetter();
         }
@@ -52,7 +52,7 @@ public class JetPropertyAccessor extends JetDeclarationStub<PsiJetPropertyAccess
     }
 
     public boolean isGetter() {
-        PsiJetPropertyAccessorStub stub = getStub();
+        KotlinPropertyAccessorStub stub = getStub();
         if (stub != null) {
             return stub.isGetter();
         }
@@ -91,7 +91,7 @@ public class JetPropertyAccessor extends JetDeclarationStub<PsiJetPropertyAccess
 
     @Override
     public boolean hasBody() {
-        PsiJetPropertyAccessorStub stub = getStub();
+        KotlinPropertyAccessorStub stub = getStub();
         if (stub != null) {
             return stub.hasBody();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeArgumentList.java

@@ -18,17 +18,17 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.List;
 
-public class JetTypeArgumentList extends JetElementImplStub<PsiJetPlaceHolderStub<JetTypeArgumentList>> {
+public class JetTypeArgumentList extends JetElementImplStub<KotlinPlaceHolderStub<JetTypeArgumentList>> {
     public JetTypeArgumentList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeArgumentList(@NotNull PsiJetPlaceHolderStub<JetTypeArgumentList> stub) {
+    public JetTypeArgumentList(@NotNull KotlinPlaceHolderStub<JetTypeArgumentList> stub) {
         super(stub, JetStubElementTypes.TYPE_ARGUMENT_LIST);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeConstraint.java

@@ -19,16 +19,16 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetTypeConstraintStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinTypeConstraintStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
-public class JetTypeConstraint extends JetElementImplStub<PsiJetTypeConstraintStub> {
+public class JetTypeConstraint extends JetElementImplStub<KotlinTypeConstraintStub> {
     public JetTypeConstraint(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeConstraint(@NotNull PsiJetTypeConstraintStub stub) {
+    public JetTypeConstraint(@NotNull KotlinTypeConstraintStub stub) {
         super(stub, JetStubElementTypes.TYPE_CONSTRAINT);
     }
 
@@ -38,7 +38,7 @@ public class JetTypeConstraint extends JetElementImplStub<PsiJetTypeConstraintSt
     }
 
     public boolean isClassObjectConstraint() {
-        PsiJetTypeConstraintStub stub = getStub();
+        KotlinTypeConstraintStub stub = getStub();
         if (stub != null) {
             return stub.isClassObjectConstraint();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeConstraintList.java

@@ -18,18 +18,17 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetNodeTypes;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.List;
 
-public class JetTypeConstraintList extends JetElementImplStub<PsiJetPlaceHolderStub<JetTypeConstraintList>> {
+public class JetTypeConstraintList extends JetElementImplStub<KotlinPlaceHolderStub<JetTypeConstraintList>> {
     public JetTypeConstraintList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeConstraintList(@NotNull PsiJetPlaceHolderStub<JetTypeConstraintList> stub) {
+    public JetTypeConstraintList(@NotNull KotlinPlaceHolderStub<JetTypeConstraintList> stub) {
         super(stub, JetStubElementTypes.TYPE_CONSTRAINT_LIST);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeParameter.java

@@ -19,18 +19,18 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetTypeParameterStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinTypeParameterStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.types.Variance;
 import org.jetbrains.jet.lexer.JetTokens;
 
-public class JetTypeParameter extends JetNamedDeclarationStub<PsiJetTypeParameterStub> {
+public class JetTypeParameter extends JetNamedDeclarationStub<KotlinTypeParameterStub> {
 
     public JetTypeParameter(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeParameter(@NotNull PsiJetTypeParameterStub stub) {
+    public JetTypeParameter(@NotNull KotlinTypeParameterStub stub) {
         super(stub, JetStubElementTypes.TYPE_PARAMETER);
     }
 
@@ -41,7 +41,7 @@ public class JetTypeParameter extends JetNamedDeclarationStub<PsiJetTypeParamete
 
     @NotNull
     public Variance getVariance() {
-        PsiJetTypeParameterStub stub = getStub();
+        KotlinTypeParameterStub stub = getStub();
         if (stub != null) {
             if (stub.isOutVariance()) return Variance.OUT_VARIANCE;
             if (stub.isInVariance()) return Variance.IN_VARIANCE;

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeParameterList.java

@@ -18,17 +18,17 @@ package org.jetbrains.jet.lang.psi;
 
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.List;
 
-public class JetTypeParameterList extends JetElementImplStub<PsiJetPlaceHolderStub<JetTypeParameterList>> {
+public class JetTypeParameterList extends JetElementImplStub<KotlinPlaceHolderStub<JetTypeParameterList>> {
     public JetTypeParameterList(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeParameterList(@NotNull PsiJetPlaceHolderStub<JetTypeParameterList> stub) {
+    public JetTypeParameterList(@NotNull KotlinPlaceHolderStub<JetTypeParameterList> stub) {
         super(stub, JetStubElementTypes.TYPE_PARAMETER_LIST);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeParameterListOwnerStub.java

@@ -20,13 +20,13 @@ import com.intellij.lang.ASTNode;
 import com.intellij.psi.stubs.IStubElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetStubWithFqName;
+import org.jetbrains.jet.lang.psi.stubs.KotlinStubWithFqName;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.Collections;
 import java.util.List;
 
-abstract class JetTypeParameterListOwnerStub<T extends PsiJetStubWithFqName> extends JetNamedDeclarationStub<T> implements JetTypeParameterListOwner {
+abstract class JetTypeParameterListOwnerStub<T extends KotlinStubWithFqName> extends JetNamedDeclarationStub<T> implements JetTypeParameterListOwner {
     public JetTypeParameterListOwnerStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
         super(stub, nodeType);
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeProjection.java

@@ -21,23 +21,23 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.tree.IElementType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetTypeProjectionStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinTypeProjectionStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
-public class JetTypeProjection extends JetModifierListOwnerStub<PsiJetTypeProjectionStub> {
+public class JetTypeProjection extends JetModifierListOwnerStub<KotlinTypeProjectionStub> {
 
     public JetTypeProjection(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeProjection(@NotNull PsiJetTypeProjectionStub stub) {
+    public JetTypeProjection(@NotNull KotlinTypeProjectionStub stub) {
         super(stub, JetStubElementTypes.TYPE_PROJECTION);
     }
 
     @NotNull
     public JetProjectionKind getProjectionKind() {
-        PsiJetTypeProjectionStub stub = getStub();
+        KotlinTypeProjectionStub stub = getStub();
         if (stub != null) {
             return stub.getProjectionKind();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetTypeReference.java

@@ -19,7 +19,7 @@ package org.jetbrains.jet.lang.psi;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
 import java.util.ArrayList;
@@ -32,13 +32,13 @@ import static org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes.ANNO
  * Type reference element.
  * Underlying token is {@link org.jetbrains.jet.JetNodeTypes#TYPE_REFERENCE}
  */
-public class JetTypeReference extends JetElementImplStub<PsiJetPlaceHolderStub<JetTypeReference>> {
+public class JetTypeReference extends JetElementImplStub<KotlinPlaceHolderStub<JetTypeReference>> {
 
     public JetTypeReference(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetTypeReference(PsiJetPlaceHolderStub<JetTypeReference> stub) {
+    public JetTypeReference(KotlinPlaceHolderStub<JetTypeReference> stub) {
         super(stub, JetStubElementTypes.TYPE_REFERENCE);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetUserType.java

@@ -20,25 +20,24 @@ import com.google.common.collect.Lists;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.JetNodeTypes;
+import org.jetbrains.jet.lang.psi.stubs.KotlinUserTypeStub;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetUserTypeStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.Collections;
 import java.util.List;
 
-public class JetUserType extends JetElementImplStub<PsiJetUserTypeStub> implements JetTypeElement {
+public class JetUserType extends JetElementImplStub<KotlinUserTypeStub> implements JetTypeElement {
     public JetUserType(@NotNull ASTNode node) {
         super(node);
     }
 
-    public JetUserType(@NotNull PsiJetUserTypeStub stub) {
+    public JetUserType(@NotNull KotlinUserTypeStub stub) {
         super(stub, JetStubElementTypes.USER_TYPE);
     }
 
     public boolean isAbsoluteInRootPackage() {
-        PsiJetUserTypeStub stub = getStub();
+        KotlinUserTypeStub stub = getStub();
         if (stub != null) {
             return stub.isAbsoluteInRootPackage();
         }

compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt

@@ -32,7 +32,7 @@ import com.intellij.psi.PsiParameter
 import com.intellij.psi.PsiPackage
 import com.intellij.psi.JavaDirectoryService
 import com.intellij.psi.PsiDirectory
-import org.jetbrains.jet.lang.psi.stubs.PsiJetClassOrObjectStub
+import org.jetbrains.jet.lang.psi.stubs.KotlinClassOrObjectStub
 import org.jetbrains.jet.lang.types.expressions.OperatorConventions
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils
 import com.intellij.psi.PsiWhiteSpace
@@ -126,7 +126,7 @@ public fun JetElement.wrapInBlock(): JetBlockExpression {
  *
  * @return the list of possible superclass names
  */
-public fun <T: JetClassOrObject> StubBasedPsiElementBase<out PsiJetClassOrObjectStub<T>>.getSuperNames(): List<String> {
+public fun <T: JetClassOrObject> StubBasedPsiElementBase<out KotlinClassOrObjectStub<T>>.getSuperNames(): List<String> {
     fun addSuperName(result: MutableList<String>, referencedName: String): Unit {
         result.add(referencedName)
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinAnnotationEntryStub.java

@@ -20,7 +20,7 @@ import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetAnnotationEntry;
 
-public interface PsiJetAnnotationEntryStub extends StubElement<JetAnnotationEntry> {
+public interface KotlinAnnotationEntryStub extends StubElement<JetAnnotationEntry> {
     @NotNull
     String getShortName();
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinClassOrObjectStub.java

@@ -21,7 +21,7 @@ import org.jetbrains.jet.lang.psi.JetClassOrObject;
 
 import java.util.List;
 
-public interface PsiJetClassOrObjectStub<T extends JetClassOrObject> extends PsiJetStubWithFqName<T> {
+public interface KotlinClassOrObjectStub<T extends JetClassOrObject> extends KotlinStubWithFqName<T> {
     boolean isLocal();
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinClassStub.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.psi.stubs;
 
 import org.jetbrains.jet.lang.psi.JetClass;
 
-public interface PsiJetClassStub extends PsiJetClassOrObjectStub<JetClass> {
+public interface KotlinClassStub extends KotlinClassOrObjectStub<JetClass> {
     boolean isTrait();
 
     boolean isEnumEntry();

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinFileStub.java

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
-public interface PsiJetFileStub extends PsiFileStub<JetFile> {
+public interface KotlinFileStub extends PsiFileStub<JetFile> {
     @NotNull
     FqName getPackageFqName();
     boolean isScript();

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinFunctionStub.java

@@ -16,10 +16,9 @@
 
 package org.jetbrains.jet.lang.psi.stubs;
 
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 
-public interface PsiJetFunctionStub extends PsiJetStubWithFqName<JetNamedFunction> {
+public interface KotlinFunctionStub extends KotlinStubWithFqName<JetNamedFunction> {
     boolean isTopLevel();
 
     boolean isExtension();

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinImportDirectiveStub.java

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-public interface PsiJetImportDirectiveStub extends StubElement<JetImportDirective> {
+public interface KotlinImportDirectiveStub extends StubElement<JetImportDirective> {
     boolean isAbsoluteInRootPackage();
     boolean isAllUnder();
     @Nullable

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinModifierListStub.java

@@ -21,6 +21,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetModifierList;
 import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 
-public interface PsiJetModifierListStub extends StubElement<JetModifierList> {
+public interface KotlinModifierListStub extends StubElement<JetModifierList> {
     boolean hasModifier(@NotNull JetModifierKeywordToken modifierToken);
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinNameReferenceExpressionStub.java

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetNameReferenceExpression;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-public interface PsiJetNameReferenceExpressionStub extends StubElement<JetNameReferenceExpression> {
+public interface KotlinNameReferenceExpressionStub extends StubElement<JetNameReferenceExpression> {
     @NotNull
     String getReferencedName();
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinObjectStub.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.psi.stubs;
 
 import org.jetbrains.jet.lang.psi.JetObjectDeclaration;
 
-public interface PsiJetObjectStub extends PsiJetClassOrObjectStub<JetObjectDeclaration> {
+public interface KotlinObjectStub extends KotlinClassOrObjectStub<JetObjectDeclaration> {
     boolean isClassObject();
     boolean isObjectLiteral();
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinParameterStub.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.psi.stubs;
 
 import org.jetbrains.jet.lang.psi.JetParameter;
 
-public interface PsiJetParameterStub extends PsiJetStubWithFqName<JetParameter> {
+public interface KotlinParameterStub extends KotlinStubWithFqName<JetParameter> {
     boolean isMutable();
     boolean hasValOrValNode();
     boolean hasDefaultValue();

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinPlaceHolderStub.java

@@ -19,5 +19,5 @@ package org.jetbrains.jet.lang.psi.stubs;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.jet.lang.psi.JetElement;
 
-public interface PsiJetPlaceHolderStub<T extends JetElement> extends StubElement<T> {
+public interface KotlinPlaceHolderStub<T extends JetElement> extends StubElement<T> {
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinPropertyAccessorStub.java

@@ -19,7 +19,7 @@ package org.jetbrains.jet.lang.psi.stubs;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.jet.lang.psi.JetPropertyAccessor;
 
-public interface PsiJetPropertyAccessorStub extends StubElement<JetPropertyAccessor> {
+public interface KotlinPropertyAccessorStub extends StubElement<JetPropertyAccessor> {
     boolean isGetter();
     boolean hasBody();
     boolean hasBlockBody();

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinPropertyStub.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.psi.stubs;
 
 import org.jetbrains.jet.lang.psi.JetProperty;
 
-public interface PsiJetPropertyStub extends PsiJetStubWithFqName<JetProperty> {
+public interface KotlinPropertyStub extends KotlinStubWithFqName<JetProperty> {
     boolean isVar();
     boolean isTopLevel();
     boolean hasDelegate();

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinStubWithFqName.java

@@ -21,7 +21,7 @@ import com.intellij.psi.stubs.NamedStub;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
-public interface PsiJetStubWithFqName<T extends PsiNamedElement> extends NamedStub<T> {
+public interface KotlinStubWithFqName<T extends PsiNamedElement> extends NamedStub<T> {
     @Nullable
     FqName getFqName();
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinTypeConstraintStub.java

@@ -19,6 +19,6 @@ package org.jetbrains.jet.lang.psi.stubs;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.jet.lang.psi.JetTypeConstraint;
 
-public interface PsiJetTypeConstraintStub extends StubElement<JetTypeConstraint> {
+public interface KotlinTypeConstraintStub extends StubElement<JetTypeConstraint> {
     boolean isClassObjectConstraint();
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinTypeParameterStub.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.psi.stubs;
 
 import org.jetbrains.jet.lang.psi.JetTypeParameter;
 
-public interface PsiJetTypeParameterStub extends PsiJetStubWithFqName<JetTypeParameter> {
+public interface KotlinTypeParameterStub extends KotlinStubWithFqName<JetTypeParameter> {
     boolean isInVariance();
     boolean isOutVariance();
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinTypeProjectionStub.java

@@ -20,6 +20,6 @@ import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.jet.lang.psi.JetProjectionKind;
 import org.jetbrains.jet.lang.psi.JetTypeProjection;
 
-public interface PsiJetTypeProjectionStub extends StubElement<JetTypeProjection> {
+public interface KotlinTypeProjectionStub extends StubElement<JetTypeProjection> {
     JetProjectionKind getProjectionKind();
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/KotlinUserTypeStub.java

@@ -21,6 +21,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetUserType;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-public interface PsiJetUserTypeStub extends StubElement<JetUserType> {
+public interface KotlinUserTypeStub extends StubElement<JetUserType> {
     boolean isAbsoluteInRootPackage();
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetAnnotationEntryElementType.java

@@ -25,42 +25,42 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetAnnotationEntry;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetAnnotationEntryStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinAnnotationEntryStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetAnnotationEntryStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinAnnotationEntryStubImpl;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.io.IOException;
 
-public class JetAnnotationEntryElementType extends JetStubElementType<PsiJetAnnotationEntryStub, JetAnnotationEntry> {
+public class JetAnnotationEntryElementType extends JetStubElementType<KotlinAnnotationEntryStub, JetAnnotationEntry> {
 
     public JetAnnotationEntryElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetAnnotationEntry.class, PsiJetAnnotationEntryStub.class);
+        super(debugName, JetAnnotationEntry.class, KotlinAnnotationEntryStub.class);
     }
 
     @Override
-    public PsiJetAnnotationEntryStub createStub(@NotNull JetAnnotationEntry psi, StubElement parentStub) {
+    public KotlinAnnotationEntryStub createStub(@NotNull JetAnnotationEntry psi, StubElement parentStub) {
         Name shortName = JetPsiUtil.getShortName(psi);
         String resultName = shortName != null ? shortName.asString() : psi.getText();
         boolean hasValueArguments = psi.getValueArgumentList() != null;
-        return new PsiJetAnnotationEntryStubImpl(parentStub, StringRef.fromString(resultName), hasValueArguments);
+        return new KotlinAnnotationEntryStubImpl(parentStub, StringRef.fromString(resultName), hasValueArguments);
     }
 
     @Override
-    public void serialize(@NotNull PsiJetAnnotationEntryStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinAnnotationEntryStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeName(stub.getShortName());
         dataStream.writeBoolean(stub.hasValueArguments());
     }
 
     @NotNull
     @Override
-    public PsiJetAnnotationEntryStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinAnnotationEntryStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         StringRef text = dataStream.readName();
         boolean hasValueArguments = dataStream.readBoolean();
-        return new PsiJetAnnotationEntryStubImpl(parentStub, text, hasValueArguments);
+        return new KotlinAnnotationEntryStubImpl(parentStub, text, hasValueArguments);
     }
 
     @Override
-    public void indexStub(@NotNull PsiJetAnnotationEntryStub stub, @NotNull IndexSink sink) {
+    public void indexStub(@NotNull KotlinAnnotationEntryStub stub, @NotNull IndexSink sink) {
         StubIndexServiceFactory.getInstance().indexAnnotation(stub, sink);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetClassElementType.java

@@ -27,8 +27,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.lang.psi.JetEnumEntry;
 import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetClassStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinClassStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetClassStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinClassStubImpl;
 import org.jetbrains.jet.lang.psi.stubs.impl.Utils;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -36,14 +36,14 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import java.io.IOException;
 import java.util.List;
 
-public class JetClassElementType extends JetStubElementType<PsiJetClassStub, JetClass> {
+public class JetClassElementType extends JetStubElementType<KotlinClassStub, JetClass> {
     public JetClassElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetClass.class, PsiJetClassStub.class);
+        super(debugName, JetClass.class, KotlinClassStub.class);
     }
 
     @NotNull
     @Override
-    public JetClass createPsi(@NotNull PsiJetClassStub stub) {
+    public JetClass createPsi(@NotNull KotlinClassStub stub) {
         return !stub.isEnumEntry() ? new JetClass(stub) : new JetEnumEntry(stub);
     }
 
@@ -54,18 +54,18 @@ public class JetClassElementType extends JetStubElementType<PsiJetClassStub, Jet
     }
 
     @Override
-    public PsiJetClassStub createStub(@NotNull JetClass psi, StubElement parentStub) {
+    public KotlinClassStub createStub(@NotNull JetClass psi, StubElement parentStub) {
         FqName fqName = ResolveSessionUtils.safeFqNameForLazyResolve(psi);
         boolean isEnumEntry = psi instanceof JetEnumEntry;
         List<String> superNames = PsiUtilPackage.getSuperNames(psi);
-        return new PsiJetClassStubImpl(
+        return new KotlinClassStubImpl(
                 getStubType(isEnumEntry), parentStub, StringRef.fromString(fqName != null ? fqName.asString() : null),
                 StringRef.fromString(psi.getName()), Utils.INSTANCE$.wrapStrings(superNames), psi.isTrait(), isEnumEntry,
                 psi.isLocal(), psi.isTopLevel());
     }
 
     @Override
-    public void serialize(@NotNull PsiJetClassStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinClassStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeName(stub.getName());
         FqName fqName = stub.getFqName();
         dataStream.writeName(fqName == null ? null : fqName.asString());
@@ -83,7 +83,7 @@ public class JetClassElementType extends JetStubElementType<PsiJetClassStub, Jet
 
     @NotNull
     @Override
-    public PsiJetClassStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinClassStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         StringRef name = dataStream.readName();
         StringRef qualifiedName = dataStream.readName();
         boolean isTrait = dataStream.readBoolean();
@@ -97,12 +97,12 @@ public class JetClassElementType extends JetStubElementType<PsiJetClassStub, Jet
             superNames[i] = dataStream.readName();
         }
 
-        return new PsiJetClassStubImpl(getStubType(isEnumEntry), parentStub, qualifiedName, name, superNames,
+        return new KotlinClassStubImpl(getStubType(isEnumEntry), parentStub, qualifiedName, name, superNames,
                                        isTrait, isEnumEntry, isLocal, isTopLevel);
     }
 
     @Override
-    public void indexStub(@NotNull PsiJetClassStub stub, @NotNull IndexSink sink) {
+    public void indexStub(@NotNull KotlinClassStub stub, @NotNull IndexSink sink) {
         StubIndexServiceFactory.getInstance().indexClass(stub, sink);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetFileElementType.java

@@ -29,13 +29,13 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.parsing.JetParser;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetFileStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinFileStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetFileStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinFileStubImpl;
 import org.jetbrains.jet.plugin.JetLanguage;
 
 import java.io.IOException;
 
-public class JetFileElementType extends IStubFileElementType<PsiJetFileStub> {
+public class JetFileElementType extends IStubFileElementType<KotlinFileStub> {
     public static final int STUB_VERSION = 30;
 
     public JetFileElementType() {
@@ -63,7 +63,7 @@ public class JetFileElementType extends IStubFileElementType<PsiJetFileStub> {
     }
 
     @Override
-    public void serialize(@NotNull PsiJetFileStub stub, @NotNull StubOutputStream dataStream)
+    public void serialize(@NotNull KotlinFileStub stub, @NotNull StubOutputStream dataStream)
             throws IOException {
         dataStream.writeName(stub.getPackageFqName().asString());
         dataStream.writeBoolean(stub.isScript());
@@ -71,10 +71,10 @@ public class JetFileElementType extends IStubFileElementType<PsiJetFileStub> {
 
     @NotNull
     @Override
-    public PsiJetFileStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinFileStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         StringRef packageFqNameAsString = dataStream.readName();
         boolean isScript = dataStream.readBoolean();
-        return new PsiJetFileStubImpl(null, packageFqNameAsString, isScript);
+        return new KotlinFileStubImpl(null, packageFqNameAsString, isScript);
     }
 
     @Override
@@ -87,7 +87,7 @@ public class JetFileElementType extends IStubFileElementType<PsiJetFileStub> {
     }
 
     @Override
-    public void indexStub(@NotNull PsiJetFileStub stub, @NotNull IndexSink sink) {
+    public void indexStub(@NotNull KotlinFileStub stub, @NotNull IndexSink sink) {
         StubIndexServiceFactory.getInstance().indexFile(stub, sink);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetFileStubBuilder.java

@@ -21,7 +21,7 @@ import com.intellij.psi.stubs.DefaultStubBuilder;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetFileStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinFileStubImpl;
 
 public class JetFileStubBuilder extends DefaultStubBuilder {
     @Override
@@ -31,6 +31,6 @@ public class JetFileStubBuilder extends DefaultStubBuilder {
         }
 
         JetFile jetFile = (JetFile) file;
-        return new PsiJetFileStubImpl(jetFile, jetFile.getPackageFqNameByTree().asString(), jetFile.isScriptByTree());
+        return new KotlinFileStubImpl(jetFile, jetFile.getPackageFqNameByTree().asString(), jetFile.isScriptByTree());
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetFunctionElementType.java

@@ -25,32 +25,32 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetFunctionStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinFunctionStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetFunctionStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinFunctionStubImpl;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.io.IOException;
 
-public class JetFunctionElementType extends JetStubElementType<PsiJetFunctionStub, JetNamedFunction> {
+public class JetFunctionElementType extends JetStubElementType<KotlinFunctionStub, JetNamedFunction> {
 
     public JetFunctionElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetNamedFunction.class, PsiJetFunctionStub.class);
+        super(debugName, JetNamedFunction.class, KotlinFunctionStub.class);
     }
 
     @Override
-    public PsiJetFunctionStub createStub(@NotNull JetNamedFunction psi, @NotNull StubElement parentStub) {
+    public KotlinFunctionStub createStub(@NotNull JetNamedFunction psi, @NotNull StubElement parentStub) {
         boolean isTopLevel = psi.getParent() instanceof JetFile;
         boolean isExtension = psi.getReceiverTypeReference() != null;
         FqName fqName = ResolveSessionUtils.safeFqNameForLazyResolve(psi);
         boolean hasBlockBody = psi.hasBlockBody();
         boolean hasBody = psi.hasBody();
-        return new PsiJetFunctionStubImpl(parentStub, StringRef.fromString(psi.getName()), isTopLevel, fqName,
+        return new KotlinFunctionStubImpl(parentStub, StringRef.fromString(psi.getName()), isTopLevel, fqName,
                                           isExtension, hasBlockBody, hasBody, psi.hasTypeParameterListBeforeFunctionName());
     }
 
     @Override
-    public void serialize(@NotNull PsiJetFunctionStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinFunctionStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeName(stub.getName());
         dataStream.writeBoolean(stub.isTopLevel());
 
@@ -65,7 +65,7 @@ public class JetFunctionElementType extends JetStubElementType<PsiJetFunctionStu
 
     @NotNull
     @Override
-    public PsiJetFunctionStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinFunctionStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         StringRef name = dataStream.readName();
         boolean isTopLevel = dataStream.readBoolean();
 
@@ -77,12 +77,12 @@ public class JetFunctionElementType extends JetStubElementType<PsiJetFunctionStu
         boolean hasBody = dataStream.readBoolean();
         boolean hasTypeParameterListBeforeFunctionName = dataStream.readBoolean();
 
-        return new PsiJetFunctionStubImpl(parentStub, name, isTopLevel, fqName, isExtension, hasBlockBody, hasBody,
+        return new KotlinFunctionStubImpl(parentStub, name, isTopLevel, fqName, isExtension, hasBlockBody, hasBody,
                                           hasTypeParameterListBeforeFunctionName);
     }
 
     @Override
-    public void indexStub(@NotNull PsiJetFunctionStub stub, @NotNull IndexSink sink) {
+    public void indexStub(@NotNull KotlinFunctionStub stub, @NotNull IndexSink sink) {
         StubIndexServiceFactory.getInstance().indexFunction(stub, sink);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetImportDirectiveElementType.java

@@ -23,25 +23,25 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetImportDirectiveStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinImportDirectiveStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetImportDirectiveStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinImportDirectiveStubImpl;
 
 import java.io.IOException;
 
-public class JetImportDirectiveElementType extends JetStubElementType<PsiJetImportDirectiveStub, JetImportDirective> {
+public class JetImportDirectiveElementType extends JetStubElementType<KotlinImportDirectiveStub, JetImportDirective> {
     public JetImportDirectiveElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetImportDirective.class, PsiJetImportDirectiveStub.class);
+        super(debugName, JetImportDirective.class, KotlinImportDirectiveStub.class);
     }
 
     @Override
-    public PsiJetImportDirectiveStub createStub(@NotNull JetImportDirective psi, StubElement parentStub) {
+    public KotlinImportDirectiveStub createStub(@NotNull JetImportDirective psi, StubElement parentStub) {
         StringRef aliasName = StringRef.fromString(psi.getAliasName());
-        return new PsiJetImportDirectiveStubImpl(parentStub, psi.isAbsoluteInRootPackage(), psi.isAllUnder(),
+        return new KotlinImportDirectiveStubImpl(parentStub, psi.isAbsoluteInRootPackage(), psi.isAllUnder(),
                                                  aliasName, psi.isValidImport());
     }
 
     @Override
-    public void serialize(@NotNull PsiJetImportDirectiveStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinImportDirectiveStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeBoolean(stub.isAbsoluteInRootPackage());
         dataStream.writeBoolean(stub.isAllUnder());
         dataStream.writeName(stub.getAliasName());
@@ -50,11 +50,11 @@ public class JetImportDirectiveElementType extends JetStubElementType<PsiJetImpo
 
     @NotNull
     @Override
-    public PsiJetImportDirectiveStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinImportDirectiveStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         boolean isAbsoluteInRootPackage = dataStream.readBoolean();
         boolean isAllUnder = dataStream.readBoolean();
         StringRef aliasName = dataStream.readName();
         boolean isValid = dataStream.readBoolean();
-        return new PsiJetImportDirectiveStubImpl(parentStub, isAbsoluteInRootPackage, isAllUnder, aliasName, isValid);
+        return new KotlinImportDirectiveStubImpl(parentStub, isAbsoluteInRootPackage, isAllUnder, aliasName, isValid);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetModifierListElementType.java

@@ -22,33 +22,33 @@ import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetModifierList;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetModifierListStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinModifierListStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetModifierListStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinModifierListStubImpl;
 
 import java.io.IOException;
 
-import static org.jetbrains.jet.lang.psi.stubs.impl.PsiJetModifierListStubImpl.computeMaskFromPsi;
+import static org.jetbrains.jet.lang.psi.stubs.impl.KotlinModifierListStubImpl.computeMaskFromPsi;
 
-public class JetModifierListElementType<T extends JetModifierList> extends JetStubElementType<PsiJetModifierListStub, T> {
+public class JetModifierListElementType<T extends JetModifierList> extends JetStubElementType<KotlinModifierListStub, T> {
     public JetModifierListElementType(@NotNull @NonNls String debugName, @NotNull Class<T> psiClass) {
-        super(debugName, psiClass, PsiJetModifierListStub.class);
+        super(debugName, psiClass, KotlinModifierListStub.class);
     }
 
     @Override
-    public PsiJetModifierListStub createStub(@NotNull T psi, StubElement parentStub) {
+    public KotlinModifierListStub createStub(@NotNull T psi, StubElement parentStub) {
-        return new PsiJetModifierListStubImpl(parentStub, computeMaskFromPsi(psi), this);
+        return new KotlinModifierListStubImpl(parentStub, computeMaskFromPsi(psi), this);
     }
 
     @Override
-    public void serialize(@NotNull PsiJetModifierListStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinModifierListStub stub, @NotNull StubOutputStream dataStream) throws IOException {
-        int mask = ((PsiJetModifierListStubImpl) stub).getMask();
+        int mask = ((KotlinModifierListStubImpl) stub).getMask();
         dataStream.writeVarInt(mask);
     }
 
     @NotNull
     @Override
-    public PsiJetModifierListStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinModifierListStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         int mask = dataStream.readVarInt();
-        return new PsiJetModifierListStubImpl(parentStub, mask, this);
+        return new KotlinModifierListStubImpl(parentStub, mask, this);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetNameReferenceExpressionElementType.java

@@ -23,30 +23,30 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetNameReferenceExpression;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetNameReferenceExpressionStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinNameReferenceExpressionStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetNameReferenceExpressionStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinNameReferenceExpressionStubImpl;
 
 import java.io.IOException;
 
-public class JetNameReferenceExpressionElementType extends JetStubElementType<PsiJetNameReferenceExpressionStub, JetNameReferenceExpression> {
+public class JetNameReferenceExpressionElementType extends JetStubElementType<KotlinNameReferenceExpressionStub, JetNameReferenceExpression> {
     public JetNameReferenceExpressionElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetNameReferenceExpression.class, PsiJetNameReferenceExpressionStub.class);
+        super(debugName, JetNameReferenceExpression.class, KotlinNameReferenceExpressionStub.class);
     }
 
     @Override
-    public PsiJetNameReferenceExpressionStub createStub(@NotNull JetNameReferenceExpression psi, StubElement parentStub) {
+    public KotlinNameReferenceExpressionStub createStub(@NotNull JetNameReferenceExpression psi, StubElement parentStub) {
-        return new PsiJetNameReferenceExpressionStubImpl(parentStub, StringRef.fromString(psi.getReferencedName()));
+        return new KotlinNameReferenceExpressionStubImpl(parentStub, StringRef.fromString(psi.getReferencedName()));
     }
 
     @Override
-    public void serialize(@NotNull PsiJetNameReferenceExpressionStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinNameReferenceExpressionStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeName(stub.getReferencedName());
     }
 
     @NotNull
     @Override
-    public PsiJetNameReferenceExpressionStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinNameReferenceExpressionStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         StringRef referencedName = dataStream.readName();
-        return new PsiJetNameReferenceExpressionStubImpl(parentStub, referencedName);
+        return new KotlinNameReferenceExpressionStubImpl(parentStub, referencedName);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetObjectElementType.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.lang.psi.stubs.elements;
 
-import com.intellij.lang.ASTNode;
 import com.intellij.psi.stubs.IndexSink;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.stubs.StubInputStream;
@@ -26,10 +25,9 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetClassObject;
 import org.jetbrains.jet.lang.psi.JetObjectDeclaration;
-import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetObjectStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinObjectStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetObjectStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinObjectStubImpl;
 import org.jetbrains.jet.lang.psi.stubs.impl.Utils;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -37,22 +35,22 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import java.io.IOException;
 import java.util.List;
 
-public class JetObjectElementType extends JetStubElementType<PsiJetObjectStub, JetObjectDeclaration> {
+public class JetObjectElementType extends JetStubElementType<KotlinObjectStub, JetObjectDeclaration> {
     public JetObjectElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetObjectDeclaration.class, PsiJetObjectStub.class);
+        super(debugName, JetObjectDeclaration.class, KotlinObjectStub.class);
     }
 
     @Override
-    public PsiJetObjectStub createStub(@NotNull JetObjectDeclaration psi, StubElement parentStub) {
+    public KotlinObjectStub createStub(@NotNull JetObjectDeclaration psi, StubElement parentStub) {
         String name = psi.getName();
         FqName fqName = ResolveSessionUtils.safeFqNameForLazyResolve(psi);
         List<String> superNames = PsiUtilPackage.getSuperNames(psi);
-        return new PsiJetObjectStubImpl(parentStub, StringRef.fromString(name), fqName, Utils.INSTANCE$.wrapStrings(superNames),
+        return new KotlinObjectStubImpl(parentStub, StringRef.fromString(name), fqName, Utils.INSTANCE$.wrapStrings(superNames),
                                         psi.isTopLevel(), isClassObject(psi), psi.isLocal(), psi.isObjectLiteral());
     }
 
     @Override
-    public void serialize(@NotNull PsiJetObjectStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinObjectStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeName(stub.getName());
 
         FqName fqName = stub.getFqName();
@@ -72,7 +70,7 @@ public class JetObjectElementType extends JetStubElementType<PsiJetObjectStub, J
 
     @NotNull
     @Override
-    public PsiJetObjectStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinObjectStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         StringRef name = dataStream.readName();
         StringRef fqNameStr = dataStream.readName();
         FqName fqName = fqNameStr != null ? new FqName(fqNameStr.toString()) : null;
@@ -88,11 +86,11 @@ public class JetObjectElementType extends JetStubElementType<PsiJetObjectStub, J
             superNames[i] = dataStream.readName();
         }
 
-        return new PsiJetObjectStubImpl(parentStub, name, fqName, superNames, isTopLevel, isClassObject, isLocal, isObjectLiteral);
+        return new KotlinObjectStubImpl(parentStub, name, fqName, superNames, isTopLevel, isClassObject, isLocal, isObjectLiteral);
     }
 
     @Override
-    public void indexStub(@NotNull PsiJetObjectStub stub, @NotNull IndexSink sink) {
+    public void indexStub(@NotNull KotlinObjectStub stub, @NotNull IndexSink sink) {
         StubIndexServiceFactory.getInstance().indexObject(stub, sink);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetParameterElementType.java

@@ -16,8 +16,6 @@
 
 package org.jetbrains.jet.lang.psi.stubs.elements;
 
-import com.intellij.lang.ASTNode;
-import com.intellij.psi.PsiElement;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.stubs.StubInputStream;
 import com.intellij.psi.stubs.StubOutputStream;
@@ -25,27 +23,27 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetParameter;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetParameterStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinParameterStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetParameterStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinParameterStubImpl;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.io.IOException;
 
-public class JetParameterElementType extends JetStubElementType<PsiJetParameterStub, JetParameter> {
+public class JetParameterElementType extends JetStubElementType<KotlinParameterStub, JetParameter> {
     public JetParameterElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetParameter.class, PsiJetParameterStub.class);
+        super(debugName, JetParameter.class, KotlinParameterStub.class);
     }
 
     @Override
-    public PsiJetParameterStub createStub(@NotNull JetParameter psi, StubElement parentStub) {
+    public KotlinParameterStub createStub(@NotNull JetParameter psi, StubElement parentStub) {
         FqName fqName = psi.getFqName();
         StringRef fqNameRef = StringRef.fromString(fqName != null ? fqName.asString() : null);
-        return new PsiJetParameterStubImpl(parentStub, fqNameRef, StringRef.fromString(psi.getName()),
+        return new KotlinParameterStubImpl(parentStub, fqNameRef, StringRef.fromString(psi.getName()),
                                            psi.isMutable(), psi.hasValOrVarNode(), psi.hasDefaultValue());
     }
 
     @Override
-    public void serialize(@NotNull PsiJetParameterStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinParameterStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeName(stub.getName());
         dataStream.writeBoolean(stub.isMutable());
         dataStream.writeBoolean(stub.hasValOrValNode());
@@ -56,13 +54,13 @@ public class JetParameterElementType extends JetStubElementType<PsiJetParameterS
 
     @NotNull
     @Override
-    public PsiJetParameterStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinParameterStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         StringRef name = dataStream.readName();
         boolean isMutable = dataStream.readBoolean();
         boolean hasValOrValNode = dataStream.readBoolean();
         boolean hasDefaultValue = dataStream.readBoolean();
         StringRef fqName = dataStream.readName();
 
-         return new PsiJetParameterStubImpl(parentStub, fqName, name, isMutable, hasValOrValNode, hasDefaultValue);
+         return new KotlinParameterStubImpl(parentStub, fqName, name, isMutable, hasValOrValNode, hasDefaultValue);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetPlaceHolderStubElementType.java

@@ -22,30 +22,30 @@ import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetElementImplStub;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetPlaceHolderStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinPlaceHolderStubImpl;
 
 import java.io.IOException;
 
-public class JetPlaceHolderStubElementType<T extends JetElementImplStub<? extends StubElement<?>>> extends JetStubElementType<PsiJetPlaceHolderStub<T>, T> {
+public class JetPlaceHolderStubElementType<T extends JetElementImplStub<? extends StubElement<?>>> extends JetStubElementType<KotlinPlaceHolderStub<T>, T> {
 
     public JetPlaceHolderStubElementType(@NotNull @NonNls String debugName, @NotNull Class<T> psiClass) {
-        super(debugName, psiClass, PsiJetPlaceHolderStub.class);
+        super(debugName, psiClass, KotlinPlaceHolderStub.class);
     }
 
     @Override
-    public PsiJetPlaceHolderStub<T> createStub(@NotNull T psi, StubElement parentStub) {
+    public KotlinPlaceHolderStub<T> createStub(@NotNull T psi, StubElement parentStub) {
-        return new PsiJetPlaceHolderStubImpl<T>(parentStub, this);
+        return new KotlinPlaceHolderStubImpl<T>(parentStub, this);
     }
 
     @Override
-    public void serialize(@NotNull PsiJetPlaceHolderStub<T> stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinPlaceHolderStub<T> stub, @NotNull StubOutputStream dataStream) throws IOException {
         //do nothing
     }
 
     @NotNull
     @Override
-    public PsiJetPlaceHolderStub<T> deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinPlaceHolderStub<T> deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
-        return new PsiJetPlaceHolderStubImpl<T>(parentStub, this);
+        return new KotlinPlaceHolderStubImpl<T>(parentStub, this);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetPropertyAccessorElementType.java

@@ -22,23 +22,23 @@ import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetPropertyAccessor;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPropertyAccessorStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPropertyAccessorStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetPropertyAccessorStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinPropertyAccessorStubImpl;
 
 import java.io.IOException;
 
-public class JetPropertyAccessorElementType extends JetStubElementType<PsiJetPropertyAccessorStub, JetPropertyAccessor> {
+public class JetPropertyAccessorElementType extends JetStubElementType<KotlinPropertyAccessorStub, JetPropertyAccessor> {
     public JetPropertyAccessorElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetPropertyAccessor.class, PsiJetPropertyAccessorStub.class);
+        super(debugName, JetPropertyAccessor.class, KotlinPropertyAccessorStub.class);
     }
 
     @Override
-    public PsiJetPropertyAccessorStub createStub(@NotNull JetPropertyAccessor psi, StubElement parentStub) {
+    public KotlinPropertyAccessorStub createStub(@NotNull JetPropertyAccessor psi, StubElement parentStub) {
-        return new PsiJetPropertyAccessorStubImpl(parentStub, psi.isGetter(), psi.hasBody(), psi.hasBlockBody());
+        return new KotlinPropertyAccessorStubImpl(parentStub, psi.isGetter(), psi.hasBody(), psi.hasBlockBody());
     }
 
     @Override
-    public void serialize(@NotNull PsiJetPropertyAccessorStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinPropertyAccessorStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeBoolean(stub.isGetter());
         dataStream.writeBoolean(stub.hasBody());
         dataStream.writeBoolean(stub.hasBlockBody());
@@ -46,10 +46,10 @@ public class JetPropertyAccessorElementType extends JetStubElementType<PsiJetPro
 
     @NotNull
     @Override
-    public PsiJetPropertyAccessorStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinPropertyAccessorStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         boolean isGetter = dataStream.readBoolean();
         boolean hasBody = dataStream.readBoolean();
         boolean hasBlockBody = dataStream.readBoolean();
-        return new PsiJetPropertyAccessorStubImpl(parentStub, isGetter, hasBody, hasBlockBody);
+        return new KotlinPropertyAccessorStubImpl(parentStub, isGetter, hasBody, hasBlockBody);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetPropertyElementType.java

@@ -24,25 +24,25 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetProperty;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPropertyStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPropertyStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetPropertyStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinPropertyStubImpl;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.io.IOException;
 
-public class JetPropertyElementType extends JetStubElementType<PsiJetPropertyStub, JetProperty> {
+public class JetPropertyElementType extends JetStubElementType<KotlinPropertyStub, JetProperty> {
     public JetPropertyElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetProperty.class, PsiJetPropertyStub.class);
+        super(debugName, JetProperty.class, KotlinPropertyStub.class);
     }
 
     @Override
-    public PsiJetPropertyStub createStub(@NotNull JetProperty psi, StubElement parentStub) {
+    public KotlinPropertyStub createStub(@NotNull JetProperty psi, StubElement parentStub) {
         assert !psi.isLocal() :
                 String.format("Should not store local property: %s, parent %s",
                               psi.getText(), psi.getParent() != null ? psi.getParent().getText() : "<no parent>");
 
-        return new PsiJetPropertyStubImpl(
+        return new KotlinPropertyStubImpl(
                 parentStub, StringRef.fromString(psi.getName()),
                 psi.isVar(), psi.isTopLevel(), psi.hasDelegate(),
                 psi.hasDelegateExpression(), psi.hasInitializer(),
@@ -52,7 +52,7 @@ public class JetPropertyElementType extends JetStubElementType<PsiJetPropertyStu
     }
 
     @Override
-    public void serialize(@NotNull PsiJetPropertyStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinPropertyStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeName(stub.getName());
         dataStream.writeBoolean(stub.isVar());
         dataStream.writeBoolean(stub.isTopLevel());
@@ -68,7 +68,7 @@ public class JetPropertyElementType extends JetStubElementType<PsiJetPropertyStu
 
     @NotNull
     @Override
-    public PsiJetPropertyStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinPropertyStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         StringRef name = dataStream.readName();
         boolean isVar = dataStream.readBoolean();
         boolean isTopLevel = dataStream.readBoolean();
@@ -81,12 +81,12 @@ public class JetPropertyElementType extends JetStubElementType<PsiJetPropertyStu
         StringRef fqNameAsString = dataStream.readName();
         FqName fqName = fqNameAsString != null ? new FqName(fqNameAsString.toString()) : null;
 
-        return new PsiJetPropertyStubImpl(parentStub, name, isVar, isTopLevel, hasDelegate,
+        return new KotlinPropertyStubImpl(parentStub, name, isVar, isTopLevel, hasDelegate,
                                           hasDelegateExpression, hasInitializer, hasReceiverTypeRef, hasReturnTypeRef, fqName);
     }
 
     @Override
-    public void indexStub(@NotNull PsiJetPropertyStub stub, @NotNull IndexSink sink) {
+    public void indexStub(@NotNull KotlinPropertyStub stub, @NotNull IndexSink sink) {
         StubIndexServiceFactory.getInstance().indexProperty(stub, sink);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetTypeConstraintElementType.java

@@ -22,30 +22,30 @@ import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetTypeConstraint;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetTypeConstraintStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinTypeConstraintStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetTypeConstraintImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinTypeConstraintImpl;
 
 import java.io.IOException;
 
-public class JetTypeConstraintElementType extends JetStubElementType<PsiJetTypeConstraintStub, JetTypeConstraint> {
+public class JetTypeConstraintElementType extends JetStubElementType<KotlinTypeConstraintStub, JetTypeConstraint> {
     public JetTypeConstraintElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetTypeConstraint.class, PsiJetTypeConstraintStub.class);
+        super(debugName, JetTypeConstraint.class, KotlinTypeConstraintStub.class);
     }
 
     @Override
-    public PsiJetTypeConstraintStub createStub(@NotNull JetTypeConstraint psi, StubElement parentStub) {
+    public KotlinTypeConstraintStub createStub(@NotNull JetTypeConstraint psi, StubElement parentStub) {
-        return new PsiJetTypeConstraintImpl(parentStub, psi.isClassObjectConstraint());
+        return new KotlinTypeConstraintImpl(parentStub, psi.isClassObjectConstraint());
     }
 
     @Override
-    public void serialize(@NotNull PsiJetTypeConstraintStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinTypeConstraintStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeBoolean(stub.isClassObjectConstraint());
     }
 
     @NotNull
     @Override
-    public PsiJetTypeConstraintStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinTypeConstraintStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         boolean isClassObjectConstraint = dataStream.readBoolean();
-        return new PsiJetTypeConstraintImpl(parentStub, isClassObjectConstraint);
+        return new KotlinTypeConstraintImpl(parentStub, isClassObjectConstraint);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetTypeParameterElementType.java

@@ -23,26 +23,25 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetTypeParameter;
-import org.jetbrains.jet.lang.psi.JetTypeReference;
+import org.jetbrains.jet.lang.psi.stubs.KotlinTypeParameterStub;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetTypeParameterStub;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinTypeParameterStubImpl;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetTypeParameterStubImpl;
 import org.jetbrains.jet.lang.types.Variance;
 
 import java.io.IOException;
 
-public class JetTypeParameterElementType extends JetStubElementType<PsiJetTypeParameterStub, JetTypeParameter> {
+public class JetTypeParameterElementType extends JetStubElementType<KotlinTypeParameterStub, JetTypeParameter> {
     public JetTypeParameterElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetTypeParameter.class, PsiJetTypeParameterStub.class);
+        super(debugName, JetTypeParameter.class, KotlinTypeParameterStub.class);
     }
 
     @Override
-    public PsiJetTypeParameterStub createStub(@NotNull JetTypeParameter psi, StubElement parentStub) {
+    public KotlinTypeParameterStub createStub(@NotNull JetTypeParameter psi, StubElement parentStub) {
-        return new PsiJetTypeParameterStubImpl(parentStub, StringRef.fromString(psi.getName()),
+        return new KotlinTypeParameterStubImpl(parentStub, StringRef.fromString(psi.getName()),
                                                psi.getVariance() == Variance.IN_VARIANCE, psi.getVariance() == Variance.OUT_VARIANCE);
     }
 
     @Override
-    public void serialize(@NotNull PsiJetTypeParameterStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinTypeParameterStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeName(stub.getName());
         dataStream.writeBoolean(stub.isInVariance());
         dataStream.writeBoolean(stub.isOutVariance());
@@ -50,11 +49,11 @@ public class JetTypeParameterElementType extends JetStubElementType<PsiJetTypePa
 
     @NotNull
     @Override
-    public PsiJetTypeParameterStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinTypeParameterStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         StringRef name = dataStream.readName();
         boolean isInVariance = dataStream.readBoolean();
         boolean isOutVariance = dataStream.readBoolean();
 
-        return new PsiJetTypeParameterStubImpl(parentStub, name, isInVariance, isOutVariance);
+        return new KotlinTypeParameterStubImpl(parentStub, name, isInVariance, isOutVariance);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetTypeProjectionElementType.java

@@ -22,30 +22,30 @@ import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetTypeProjection;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetTypeProjectionStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinTypeProjectionStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetTypeProjectionStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinTypeProjectionStubImpl;
 
 import java.io.IOException;
 
-public class JetTypeProjectionElementType extends JetStubElementType<PsiJetTypeProjectionStub, JetTypeProjection> {
+public class JetTypeProjectionElementType extends JetStubElementType<KotlinTypeProjectionStub, JetTypeProjection> {
     public JetTypeProjectionElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetTypeProjection.class, PsiJetTypeProjectionStub.class);
+        super(debugName, JetTypeProjection.class, KotlinTypeProjectionStub.class);
     }
 
     @Override
-    public PsiJetTypeProjectionStub createStub(@NotNull JetTypeProjection psi, StubElement parentStub) {
+    public KotlinTypeProjectionStub createStub(@NotNull JetTypeProjection psi, StubElement parentStub) {
-        return new PsiJetTypeProjectionStubImpl(parentStub, psi.getProjectionKind().ordinal());
+        return new KotlinTypeProjectionStubImpl(parentStub, psi.getProjectionKind().ordinal());
     }
 
     @Override
-    public void serialize(@NotNull PsiJetTypeProjectionStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinTypeProjectionStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeVarInt(stub.getProjectionKind().ordinal());
     }
 
     @NotNull
     @Override
-    public PsiJetTypeProjectionStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinTypeProjectionStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         int projectionKindOrdinal = dataStream.readVarInt();
-        return new PsiJetTypeProjectionStubImpl(parentStub, projectionKindOrdinal);
+        return new KotlinTypeProjectionStubImpl(parentStub, projectionKindOrdinal);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetUserTypeElementType.java

@@ -22,30 +22,30 @@ import com.intellij.psi.stubs.StubOutputStream;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetUserType;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetUserTypeStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinUserTypeStub;
-import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetUserTypeStubImpl;
+import org.jetbrains.jet.lang.psi.stubs.impl.KotlinUserTypeStubImpl;
 
 import java.io.IOException;
 
-public class JetUserTypeElementType extends JetStubElementType<PsiJetUserTypeStub, JetUserType> {
+public class JetUserTypeElementType extends JetStubElementType<KotlinUserTypeStub, JetUserType> {
     public JetUserTypeElementType(@NotNull @NonNls String debugName) {
-        super(debugName, JetUserType.class, PsiJetUserTypeStub.class);
+        super(debugName, JetUserType.class, KotlinUserTypeStub.class);
     }
 
     @Override
-    public PsiJetUserTypeStub createStub(@NotNull JetUserType psi, StubElement parentStub) {
+    public KotlinUserTypeStub createStub(@NotNull JetUserType psi, StubElement parentStub) {
-        return new PsiJetUserTypeStubImpl(parentStub, psi.isAbsoluteInRootPackage());
+        return new KotlinUserTypeStubImpl(parentStub, psi.isAbsoluteInRootPackage());
     }
 
     @Override
-    public void serialize(@NotNull PsiJetUserTypeStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+    public void serialize(@NotNull KotlinUserTypeStub stub, @NotNull StubOutputStream dataStream) throws IOException {
         dataStream.writeBoolean(stub.isAbsoluteInRootPackage());
     }
 
     @NotNull
     @Override
-    public PsiJetUserTypeStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+    public KotlinUserTypeStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
         boolean isAbsoluteInRootPackage = dataStream.readBoolean();
-        return new PsiJetUserTypeStubImpl(parentStub, isAbsoluteInRootPackage);
+        return new KotlinUserTypeStubImpl(parentStub, isAbsoluteInRootPackage);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/StubIndexService.java

@@ -26,34 +26,34 @@ public interface StubIndexService {
      */
     StubIndexService NO_INDEX_SERVICE = new StubIndexService() {
         @Override
-        public void indexFile(PsiJetFileStub stub, IndexSink sink) {
+        public void indexFile(KotlinFileStub stub, IndexSink sink) {
         }
 
         @Override
-        public void indexClass(PsiJetClassStub stub, IndexSink sink) {
+        public void indexClass(KotlinClassStub stub, IndexSink sink) {
         }
 
         @Override
-        public void indexFunction(PsiJetFunctionStub stub, IndexSink sink) {
+        public void indexFunction(KotlinFunctionStub stub, IndexSink sink) {
         }
 
         @Override
-        public void indexObject(PsiJetObjectStub stub, IndexSink sink) {
+        public void indexObject(KotlinObjectStub stub, IndexSink sink) {
         }
 
         @Override
-        public void indexProperty(PsiJetPropertyStub stub, IndexSink sink) {
+        public void indexProperty(KotlinPropertyStub stub, IndexSink sink) {
         }
 
         @Override
-        public void indexAnnotation(PsiJetAnnotationEntryStub stub, IndexSink sink) {
+        public void indexAnnotation(KotlinAnnotationEntryStub stub, IndexSink sink) {
         }
     };
 
-    void indexFile(PsiJetFileStub stub, IndexSink sink);
+    void indexFile(KotlinFileStub stub, IndexSink sink);
-    void indexClass(PsiJetClassStub stub, IndexSink sink);
+    void indexClass(KotlinClassStub stub, IndexSink sink);
-    void indexFunction(PsiJetFunctionStub stub, IndexSink sink);
+    void indexFunction(KotlinFunctionStub stub, IndexSink sink);
-    void indexObject(PsiJetObjectStub stub, IndexSink sink);
+    void indexObject(KotlinObjectStub stub, IndexSink sink);
-    void indexProperty(PsiJetPropertyStub stub, IndexSink sink);
+    void indexProperty(KotlinPropertyStub stub, IndexSink sink);
-    void indexAnnotation(PsiJetAnnotationEntryStub stub, IndexSink sink);
+    void indexAnnotation(KotlinAnnotationEntryStub stub, IndexSink sink);
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinAnnotationEntryStubImpl.java

@@ -20,14 +20,14 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetAnnotationEntry;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetAnnotationEntryStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinAnnotationEntryStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class PsiJetAnnotationEntryStubImpl extends JetStubBaseImpl<JetAnnotationEntry> implements PsiJetAnnotationEntryStub {
+public class KotlinAnnotationEntryStubImpl extends KotlinStubBaseImpl<JetAnnotationEntry> implements KotlinAnnotationEntryStub {
     private final StringRef shortName;
     private final boolean hasValueArguments;
 
-    public PsiJetAnnotationEntryStubImpl(StubElement parent, @NotNull StringRef shortName, boolean hasValueArguments) {
+    public KotlinAnnotationEntryStubImpl(StubElement parent, @NotNull StringRef shortName, boolean hasValueArguments) {
         super(parent, JetStubElementTypes.ANNOTATION_ENTRY);
         this.shortName = shortName;
         this.hasValueArguments = hasValueArguments;

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinClassStubImpl.java

@@ -20,14 +20,14 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetClass;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetClassStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinClassStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetClassElementType;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class PsiJetClassStubImpl extends JetStubBaseImpl<JetClass> implements PsiJetClassStub {
+public class KotlinClassStubImpl extends KotlinStubBaseImpl<JetClass> implements KotlinClassStub {
     private final StringRef qualifiedName;
     private final StringRef name;
     private final StringRef[] superNames;
@@ -36,7 +36,7 @@ public class PsiJetClassStubImpl extends JetStubBaseImpl<JetClass> implements Ps
     private final boolean isLocal;
     private final boolean isTopLevel;
 
-    public PsiJetClassStubImpl(
+    public KotlinClassStubImpl(
             JetClassElementType type,
             StubElement parent,
             StringRef qualifiedName,

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinFileStubImpl.java

@@ -26,25 +26,25 @@ import com.intellij.psi.tree.IStubFileElementType;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetFileStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinFileStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.util.List;
 
-public class PsiJetFileStubImpl extends PsiFileStubImpl<JetFile> implements PsiJetFileStub, PsiClassHolderFileStub<JetFile> {
+public class KotlinFileStubImpl extends PsiFileStubImpl<JetFile> implements KotlinFileStub, PsiClassHolderFileStub<JetFile> {
 
     private final StringRef packageName;
     private final boolean isScript;
 
-    public PsiJetFileStubImpl(JetFile jetFile, @NotNull StringRef packageName, boolean isScript) {
+    public KotlinFileStubImpl(JetFile jetFile, @NotNull StringRef packageName, boolean isScript) {
         super(jetFile);
         this.packageName = packageName;
         // SCRIPT: PsiJetFileStubImpl knows about scripting
         this.isScript = isScript;
     }
 
-    public PsiJetFileStubImpl(JetFile jetFile, @NotNull String packageName, boolean isScript) {
+    public KotlinFileStubImpl(JetFile jetFile, @NotNull String packageName, boolean isScript) {
         this(jetFile, StringRef.fromString(packageName), isScript);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinFunctionStubImpl.java

@@ -21,11 +21,11 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetFunctionStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinFunctionStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
-public class PsiJetFunctionStubImpl extends JetStubBaseImpl<JetNamedFunction> implements PsiJetFunctionStub {
+public class KotlinFunctionStubImpl extends KotlinStubBaseImpl<JetNamedFunction> implements KotlinFunctionStub {
 
     private final StringRef nameRef;
     private final boolean isTopLevel;
@@ -35,7 +35,7 @@ public class PsiJetFunctionStubImpl extends JetStubBaseImpl<JetNamedFunction> im
     private final boolean hasBody;
     private final boolean hasTypeParameterListBeforeFunctionName;
 
-    public PsiJetFunctionStubImpl(
+    public KotlinFunctionStubImpl(
             @NotNull StubElement parent,
             @Nullable StringRef nameRef,
             boolean isTopLevel,

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinImportDirectiveStubImpl.java

@@ -20,17 +20,17 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetImportDirectiveStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinImportDirectiveStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class PsiJetImportDirectiveStubImpl extends JetStubBaseImpl<JetImportDirective> implements PsiJetImportDirectiveStub {
+public class KotlinImportDirectiveStubImpl extends KotlinStubBaseImpl<JetImportDirective> implements KotlinImportDirectiveStub {
     private final boolean isAbsoluteInRootPackage;
     private final boolean isAllUnder;
     @Nullable
     private final StringRef aliasName;
     private final boolean isValid;
 
-    public PsiJetImportDirectiveStubImpl(
+    public KotlinImportDirectiveStubImpl(
             StubElement parent,
             boolean isAbsoluteInRootPackage,
             boolean isAllUnder,

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinModifierListStubImpl.java

@@ -20,13 +20,13 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetModifierList;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetModifierListStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinModifierListStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetModifierListElementType;
 import org.jetbrains.jet.lexer.JetModifierKeywordToken;
 
 import static org.jetbrains.jet.lexer.JetTokens.MODIFIER_KEYWORDS_ARRAY;
 
-public class PsiJetModifierListStubImpl extends JetStubBaseImpl<JetModifierList> implements PsiJetModifierListStub {
+public class KotlinModifierListStubImpl extends KotlinStubBaseImpl<JetModifierList> implements KotlinModifierListStub {
 
     static {
         assert MODIFIER_KEYWORDS_ARRAY.length <= 32 : "Current implementation depends on the ability to represent modifier list as bit mask";
@@ -46,7 +46,7 @@ public class PsiJetModifierListStubImpl extends JetStubBaseImpl<JetModifierList>
 
     private final int mask;
 
-    public PsiJetModifierListStubImpl(StubElement parent, int mask, @NotNull JetModifierListElementType<?> elementType) {
+    public KotlinModifierListStubImpl(StubElement parent, int mask, @NotNull JetModifierListElementType<?> elementType) {
         super(parent, elementType);
         this.mask = mask;
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinNameReferenceExpressionStubImpl.java

@@ -20,14 +20,15 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.JetNameReferenceExpression;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetNameReferenceExpressionStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinNameReferenceExpressionStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class PsiJetNameReferenceExpressionStubImpl extends JetStubBaseImpl<JetNameReferenceExpression> implements PsiJetNameReferenceExpressionStub {
+public class KotlinNameReferenceExpressionStubImpl extends KotlinStubBaseImpl<JetNameReferenceExpression> implements
+                                                                                                       KotlinNameReferenceExpressionStub {
     @NotNull
     private final StringRef referencedName;
 
-    public PsiJetNameReferenceExpressionStubImpl(StubElement parent, @NotNull StringRef referencedName) {
+    public KotlinNameReferenceExpressionStubImpl(StubElement parent, @NotNull StringRef referencedName) {
         super(parent, JetStubElementTypes.REFERENCE_EXPRESSION);
         this.referencedName = referencedName;
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinObjectStubImpl.java

@@ -21,14 +21,14 @@ import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetObjectDeclaration;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetObjectStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinObjectStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class PsiJetObjectStubImpl extends JetStubBaseImpl<JetObjectDeclaration> implements PsiJetObjectStub {
+public class KotlinObjectStubImpl extends KotlinStubBaseImpl<JetObjectDeclaration> implements KotlinObjectStub {
     private final StringRef name;
     private final FqName fqName;
     private final StringRef[] superNames;
@@ -37,7 +37,7 @@ public class PsiJetObjectStubImpl extends JetStubBaseImpl<JetObjectDeclaration>
     private final boolean isLocal;
     private final boolean isObjectLiteral;
 
-    public PsiJetObjectStubImpl(
+    public KotlinObjectStubImpl(
             @NotNull StubElement parent,
             @Nullable StringRef name,
             @Nullable FqName fqName,

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinParameterStubImpl.java

@@ -20,18 +20,18 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetParameter;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetParameterStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinParameterStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
-public class PsiJetParameterStubImpl extends JetStubBaseImpl<JetParameter> implements PsiJetParameterStub {
+public class KotlinParameterStubImpl extends KotlinStubBaseImpl<JetParameter> implements KotlinParameterStub {
     private final StringRef name;
     private final boolean isMutable;
     private final StringRef fqName;
     private final boolean hasValOrValNode;
     private final boolean hasDefaultValue;
 
-    public PsiJetParameterStubImpl(
+    public KotlinParameterStubImpl(
             StubElement parent,
             StringRef fqName, StringRef name,
             boolean isMutable,

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinPlaceHolderStubImpl.java

@@ -19,11 +19,11 @@ package org.jetbrains.jet.lang.psi.stubs.impl;
 import com.intellij.psi.stubs.IStubElementType;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.jet.lang.psi.JetElementImplStub;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub;
 
-public class PsiJetPlaceHolderStubImpl<T extends JetElementImplStub<? extends StubElement<?>>> extends JetStubBaseImpl<T>
+public class KotlinPlaceHolderStubImpl<T extends JetElementImplStub<? extends StubElement<?>>> extends KotlinStubBaseImpl<T>
-        implements PsiJetPlaceHolderStub<T> {
+        implements KotlinPlaceHolderStub<T> {
-    public PsiJetPlaceHolderStubImpl(StubElement parent, IStubElementType elementType) {
+    public KotlinPlaceHolderStubImpl(StubElement parent, IStubElementType elementType) {
         //noinspection unchecked
         super(parent, elementType);
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinPropertyAccessorStubImpl.java

@@ -18,15 +18,15 @@ package org.jetbrains.jet.lang.psi.stubs.impl;
 
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.jet.lang.psi.JetPropertyAccessor;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPropertyAccessorStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPropertyAccessorStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class PsiJetPropertyAccessorStubImpl extends JetStubBaseImpl<JetPropertyAccessor> implements PsiJetPropertyAccessorStub {
+public class KotlinPropertyAccessorStubImpl extends KotlinStubBaseImpl<JetPropertyAccessor> implements KotlinPropertyAccessorStub {
     private final boolean isGetter;
     private final boolean hasBody;
     private final boolean hasBlockBody;
 
-    public PsiJetPropertyAccessorStubImpl(StubElement parent, boolean isGetter, boolean hasBody, boolean hasBlockBody) {
+    public KotlinPropertyAccessorStubImpl(StubElement parent, boolean isGetter, boolean hasBody, boolean hasBlockBody) {
         super(parent, JetStubElementTypes.PROPERTY_ACCESSOR);
         this.isGetter = isGetter;
         this.hasBody = hasBody;

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinPropertyStubImpl.java

@@ -20,11 +20,11 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetProperty;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPropertyStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinPropertyStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
-public class PsiJetPropertyStubImpl extends JetStubBaseImpl<JetProperty> implements PsiJetPropertyStub {
+public class KotlinPropertyStubImpl extends KotlinStubBaseImpl<JetProperty> implements KotlinPropertyStub {
     private final StringRef name;
     private final boolean isVar;
     private final boolean isTopLevel;
@@ -35,7 +35,7 @@ public class PsiJetPropertyStubImpl extends JetStubBaseImpl<JetProperty> impleme
     private final boolean hasReturnTypeRef;
     private final FqName fqName;
 
-    public PsiJetPropertyStubImpl(
+    public KotlinPropertyStubImpl(
             StubElement parent,
             StringRef name,
             boolean isVar,

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinStubBaseImpl.kt

@@ -22,12 +22,12 @@ import com.intellij.psi.stubs.NamedStub
 import com.intellij.psi.stubs.StubBase
 import com.intellij.psi.stubs.StubElement
 import org.jetbrains.jet.lang.psi.JetElementImplStub
-import org.jetbrains.jet.lang.psi.stubs.PsiJetClassOrObjectStub
+import org.jetbrains.jet.lang.psi.stubs.KotlinClassOrObjectStub
-import org.jetbrains.jet.lang.psi.stubs.PsiJetStubWithFqName
+import org.jetbrains.jet.lang.psi.stubs.KotlinStubWithFqName
 import java.lang.reflect.Method
 import java.util.ArrayList
 
-public open class JetStubBaseImpl<T : JetElementImplStub<*>>(parent: StubElement<*>?, elementType: IStubElementType<*, *>) : StubBase<T>(parent, elementType) {
+public open class KotlinStubBaseImpl<T : JetElementImplStub<*>>(parent: StubElement<*>?, elementType: IStubElementType<*, *>) : StubBase<T>(parent, elementType) {
 
     override fun toString(): String {
         val stubInterface = this.javaClass.getInterfaces().first()
@@ -74,8 +74,8 @@ public open class JetStubBaseImpl<T : JetElementImplStub<*>>(parent: StubElement
     }
 
     class object {
-        private val LOGGER: Logger = Logger.getInstance(javaClass<JetStubBaseImpl<JetElementImplStub<*>>>())
+        private val LOGGER: Logger = Logger.getInstance(javaClass<KotlinStubBaseImpl<JetElementImplStub<*>>>())
 
-        private val BASE_STUB_INTERFACES = listOf(javaClass<PsiJetStubWithFqName<*>>(), javaClass<PsiJetClassOrObjectStub<*>>(), javaClass<NamedStub<*>>())
+        private val BASE_STUB_INTERFACES = listOf(javaClass<KotlinStubWithFqName<*>>(), javaClass<KotlinClassOrObjectStub<*>>(), javaClass<NamedStub<*>>())
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinTypeConstraintImpl.java

@@ -18,13 +18,13 @@ package org.jetbrains.jet.lang.psi.stubs.impl;
 
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.jet.lang.psi.JetTypeConstraint;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetTypeConstraintStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinTypeConstraintStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class PsiJetTypeConstraintImpl extends JetStubBaseImpl<JetTypeConstraint> implements PsiJetTypeConstraintStub {
+public class KotlinTypeConstraintImpl extends KotlinStubBaseImpl<JetTypeConstraint> implements KotlinTypeConstraintStub {
     private final boolean isClassObjectConstraint;
 
-    public PsiJetTypeConstraintImpl(StubElement parent, boolean isClassObjectConstraint) {
+    public KotlinTypeConstraintImpl(StubElement parent, boolean isClassObjectConstraint) {
         super(parent, JetStubElementTypes.TYPE_CONSTRAINT);
         this.isClassObjectConstraint = isClassObjectConstraint;
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinTypeParameterStubImpl.java

@@ -20,16 +20,16 @@ import com.intellij.psi.stubs.StubElement;
 import com.intellij.util.io.StringRef;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetTypeParameter;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetTypeParameterStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinTypeParameterStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
-public class PsiJetTypeParameterStubImpl extends JetStubBaseImpl<JetTypeParameter> implements PsiJetTypeParameterStub {
+public class KotlinTypeParameterStubImpl extends KotlinStubBaseImpl<JetTypeParameter> implements KotlinTypeParameterStub {
     private final StringRef name;
     private final boolean isInVariance;
     private final boolean isOutVariance;
 
-    public PsiJetTypeParameterStubImpl(StubElement parent, StringRef name, boolean isInVariance, boolean isOutVariance) {
+    public KotlinTypeParameterStubImpl(StubElement parent, StringRef name, boolean isInVariance, boolean isOutVariance) {
         super(parent, JetStubElementTypes.TYPE_PARAMETER);
 
         this.name = name;

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinTypeProjectionStubImpl.java

@@ -19,14 +19,14 @@ package org.jetbrains.jet.lang.psi.stubs.impl;
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.jet.lang.psi.JetProjectionKind;
 import org.jetbrains.jet.lang.psi.JetTypeProjection;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetTypeProjectionStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinTypeProjectionStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class PsiJetTypeProjectionStubImpl extends JetStubBaseImpl<JetTypeProjection> implements PsiJetTypeProjectionStub {
+public class KotlinTypeProjectionStubImpl extends KotlinStubBaseImpl<JetTypeProjection> implements KotlinTypeProjectionStub {
 
     private final int projectionKindOrdinal;
 
-    public PsiJetTypeProjectionStubImpl(StubElement parent, int projectionKindOrdinal) {
+    public KotlinTypeProjectionStubImpl(StubElement parent, int projectionKindOrdinal) {
         super(parent, JetStubElementTypes.TYPE_PROJECTION);
         this.projectionKindOrdinal = projectionKindOrdinal;
     }

compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/impl/KotlinUserTypeStubImpl.java

@@ -18,13 +18,13 @@ package org.jetbrains.jet.lang.psi.stubs.impl;
 
 import com.intellij.psi.stubs.StubElement;
 import org.jetbrains.jet.lang.psi.JetUserType;
-import org.jetbrains.jet.lang.psi.stubs.PsiJetUserTypeStub;
+import org.jetbrains.jet.lang.psi.stubs.KotlinUserTypeStub;
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes;
 
-public class PsiJetUserTypeStubImpl extends JetStubBaseImpl<JetUserType> implements PsiJetUserTypeStub {
+public class KotlinUserTypeStubImpl extends KotlinStubBaseImpl<JetUserType> implements KotlinUserTypeStub {
     private final boolean isAbsoluteInRootPackage;
 
-    public PsiJetUserTypeStubImpl(StubElement parent, boolean isAbsoluteInRootPackage) {
+    public KotlinUserTypeStubImpl(StubElement parent, boolean isAbsoluteInRootPackage) {
         super(parent, JetStubElementTypes.USER_TYPE);
         this.isAbsoluteInRootPackage = isAbsoluteInRootPackage;
     }

idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/StubIndexServiceImpl.java

@@ -28,14 +28,14 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 public class StubIndexServiceImpl implements StubIndexService {
 
     @Override
-    public void indexFile(PsiJetFileStub stub, IndexSink sink) {
+    public void indexFile(KotlinFileStub stub, IndexSink sink) {
         FqName packageFqName = stub.getPackageFqName();
 
         sink.occurrence(JetExactPackagesIndex.getInstance().getKey(), packageFqName.asString());
     }
 
     @Override
-    public void indexClass(PsiJetClassStub stub, IndexSink sink) {
+    public void indexClass(KotlinClassStub stub, IndexSink sink) {
         String name = stub.getName();
         if (name != null) {
             sink.occurrence(JetClassShortNameIndex.getInstance().getKey(), name);
@@ -51,18 +51,18 @@ public class StubIndexServiceImpl implements StubIndexService {
     }
 
     @Override
-    public void indexObject(PsiJetObjectStub stub, IndexSink sink) {
+    public void indexObject(KotlinObjectStub stub, IndexSink sink) {
         String name = stub.getName();
         FqName fqName = stub.getFqName();
 
         if (stub.isClassObject()) {
             StubElement parentClassStub = stub.getParentStub().getParentStub().getParentStub();
-            assert parentClassStub instanceof PsiJetStubWithFqName<?>
+            assert parentClassStub instanceof KotlinStubWithFqName<?>
                     : "Something but a class/object is a parent to class object stub: " + parentClassStub;
 
             name = JvmAbi.CLASS_OBJECT_CLASS_NAME;
 
-            FqName parentFqName = ((PsiJetStubWithFqName<?>) parentClassStub).getFqName();
+            FqName parentFqName = ((KotlinStubWithFqName<?>) parentClassStub).getFqName();
             if (parentFqName != null) {
                 fqName = parentFqName.child(Name.identifier(name));
             }
@@ -84,7 +84,7 @@ public class StubIndexServiceImpl implements StubIndexService {
         recordClassOrObjectByPackage(stub, sink);
     }
 
-    private static void indexSuperNames(PsiJetClassOrObjectStub<? extends JetClassOrObject> stub, IndexSink sink) {
+    private static void indexSuperNames(KotlinClassOrObjectStub<? extends JetClassOrObject> stub, IndexSink sink) {
         for (String superName : stub.getSuperNames()) {
             sink.occurrence(JetSuperClassIndex.getInstance().getKey(), superName);
         }
@@ -92,15 +92,15 @@ public class StubIndexServiceImpl implements StubIndexService {
 
     private static void recordClassOrObjectByPackage(StubElement<? extends JetClassOrObject> stub, IndexSink sink) {
         StubElement parentStub = stub.getParentStub();
-        if (parentStub instanceof PsiJetFileStub) {
+        if (parentStub instanceof KotlinFileStub) {
-            PsiJetFileStub jetFileStub = (PsiJetFileStub) parentStub;
+            KotlinFileStub jetFileStub = (KotlinFileStub) parentStub;
             FqName packageFqName = jetFileStub.getPackageFqName();
             sink.occurrence(JetClassByPackageIndex.getInstance().getKey(), packageFqName.asString());
         }
     }
 
     @Override
-    public void indexFunction(PsiJetFunctionStub stub, IndexSink sink) {
+    public void indexFunction(KotlinFunctionStub stub, IndexSink sink) {
         String name = stub.getName();
         if (name != null) {
             if (stub.isTopLevel()) {
@@ -122,7 +122,7 @@ public class StubIndexServiceImpl implements StubIndexService {
     }
 
     @Override
-    public void indexProperty(PsiJetPropertyStub stub, IndexSink sink) {
+    public void indexProperty(KotlinPropertyStub stub, IndexSink sink) {
         String name = stub.getName();
         if (name != null) {
             if (stub.isTopLevel()) {
@@ -147,7 +147,7 @@ public class StubIndexServiceImpl implements StubIndexService {
     }
 
     @Override
-    public void indexAnnotation(PsiJetAnnotationEntryStub stub, IndexSink sink) {
+    public void indexAnnotation(KotlinAnnotationEntryStub stub, IndexSink sink) {
         sink.occurrence(JetAnnotationsIndex.getInstance().getKey(), stub.getShortName());
     }
 }

idea/tests/org/jetbrains/jet/plugin/stubs/DebugTextByStubTest.kt

@@ -23,17 +23,17 @@ import com.intellij.psi.stubs.StubElement
 import org.jetbrains.jet.lang.psi.stubs.elements.JetStubElementTypes
 import org.junit.Assert
 import org.jetbrains.jet.lang.psi.JetPackageDirective
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPlaceHolderStub
+import org.jetbrains.jet.lang.psi.stubs.KotlinPlaceHolderStub
 import org.jetbrains.jet.lang.psi.JetImportList
 import org.jetbrains.jet.lang.psi.JetNamedFunction
-import org.jetbrains.jet.lang.psi.stubs.PsiJetFunctionStub
+import org.jetbrains.jet.lang.psi.stubs.KotlinFunctionStub
 import org.jetbrains.jet.lang.psi.JetTypeReference
-import org.jetbrains.jet.lang.psi.stubs.PsiJetClassStub
+import org.jetbrains.jet.lang.psi.stubs.KotlinClassStub
 import org.jetbrains.jet.lang.psi.JetClass
-import org.jetbrains.jet.lang.psi.stubs.PsiJetObjectStub
+import org.jetbrains.jet.lang.psi.stubs.KotlinObjectStub
 import org.jetbrains.jet.lang.psi.JetObjectDeclaration
 import org.jetbrains.jet.lang.psi.JetProperty
-import org.jetbrains.jet.lang.psi.stubs.PsiJetPropertyStub
+import org.jetbrains.jet.lang.psi.stubs.KotlinPropertyStub
 import kotlin.test.assertEquals
 import org.jetbrains.jet.lang.psi.JetClassBody
 import org.jetbrains.jet.lang.psi.JetClassInitializer
@@ -52,14 +52,14 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
     fun packageDirective(text: String) {
         val (file, tree) = createFileAndStubTree(text)
         val packageDirective = tree.findChildStubByType(JetStubElementTypes.PACKAGE_DIRECTIVE)
-        val psi = JetPackageDirective(packageDirective as PsiJetPlaceHolderStub)
+        val psi = JetPackageDirective(packageDirective as KotlinPlaceHolderStub)
         Assert.assertEquals(file.getPackageDirective()!!.getText(), psi.getDebugText())
     }
 
     fun function(text: String) {
         val (file, tree) = createFileAndStubTree(text)
         val function = tree.findChildStubByType(JetStubElementTypes.FUNCTION)
-        val psi = JetNamedFunction(function as PsiJetFunctionStub)
+        val psi = JetNamedFunction(function as KotlinFunctionStub)
         Assert.assertEquals("STUB: " + file.findChildByClass(javaClass<JetNamedFunction>())!!.getText(), psi.getDebugText())
     }
 
@@ -69,7 +69,7 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
         val parameterList = function.findChildStubByType(JetStubElementTypes.VALUE_PARAMETER_LIST)!!
         val valueParameter = parameterList.findChildStubByType(JetStubElementTypes.VALUE_PARAMETER)!!
         val typeReferenceStub = valueParameter.findChildStubByType(JetStubElementTypes.TYPE_REFERENCE)
-        val psiFromStub = JetTypeReference(typeReferenceStub as PsiJetPlaceHolderStub)
+        val psiFromStub = JetTypeReference(typeReferenceStub as KotlinPlaceHolderStub)
         val typeReferenceByPsi = file.findChildByClass(javaClass<JetNamedFunction>())!!.getValueParameters()[0].getTypeReference()
         Assert.assertEquals(typeReferenceByPsi!!.getText(), psiFromStub.getDebugText())
     }
@@ -77,7 +77,7 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
     fun clazz(text: String, expectedText: String? = null) {
         val (file, tree) = createFileAndStubTree(text)
         val clazz = tree.findChildStubByType(JetStubElementTypes.CLASS)!!
-        val psiFromStub = JetClass(clazz as PsiJetClassStub)
+        val psiFromStub = JetClass(clazz as KotlinClassStub)
         val classByPsi = file.findChildByClass(javaClass<JetClass>())
         val toCheckAgainst = "STUB: " + (expectedText ?: classByPsi!!.getText())
         Assert.assertEquals(toCheckAgainst, psiFromStub.getDebugText())
@@ -89,7 +89,7 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
     fun obj(text: String, expectedText: String? = null) {
         val (file, tree) = createFileAndStubTree(text)
         val obj = tree.findChildStubByType(JetStubElementTypes.OBJECT_DECLARATION)!!
-        val psiFromStub = JetObjectDeclaration(obj as PsiJetObjectStub)
+        val psiFromStub = JetObjectDeclaration(obj as KotlinObjectStub)
         val objectByPsi = file.findChildByClass(javaClass<JetObjectDeclaration>())
         val toCheckAgainst = "STUB: " + (expectedText ?: objectByPsi!!.getText())
         Assert.assertEquals(toCheckAgainst, psiFromStub.getDebugText())
@@ -98,7 +98,7 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
     fun property(text: String, expectedText: String? = null) {
         val (file, tree) = createFileAndStubTree(text)
         val property = tree.findChildStubByType(JetStubElementTypes.PROPERTY)!!
-        val psiFromStub = JetProperty(property as PsiJetPropertyStub)
+        val psiFromStub = JetProperty(property as KotlinPropertyStub)
         val propertyByPsi = file.findChildByClass(javaClass<JetProperty>())
         val toCheckAgainst = "STUB: " + (expectedText ?: propertyByPsi!!.getText())
         Assert.assertEquals(toCheckAgainst, psiFromStub.getDebugText())
@@ -107,7 +107,7 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
     fun importList(text: String) {
         val (file, tree) = createFileAndStubTree(text)
         val importList = tree.findChildStubByType(JetStubElementTypes.IMPORT_LIST)
-        val psi = JetImportList(importList as PsiJetPlaceHolderStub)
+        val psi = JetImportList(importList as KotlinPlaceHolderStub)
         Assert.assertEquals(file.getImportList()!!.getText(), psi.getDebugText())
     }
 
@@ -190,21 +190,21 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() {
     fun testClassBody() {
         val tree = createStubTree("class A {\n {} fun f(): Int val c: Int}")
         val classBody = tree.findChildStubByType(JetStubElementTypes.CLASS)!!.findChildStubByType(JetStubElementTypes.CLASS_BODY)
-        assertEquals("class body for STUB: class A", JetClassBody(classBody as PsiJetPlaceHolderStub).getDebugText())
+        assertEquals("class body for STUB: class A", JetClassBody(classBody as KotlinPlaceHolderStub).getDebugText())
     }
 
     fun testClassInitializer() {
         val tree = createStubTree("class A {\n {} }")
         val initializer = tree.findChildStubByType(JetStubElementTypes.CLASS)!!.findChildStubByType(JetStubElementTypes.CLASS_BODY)!!
                 .findChildStubByType(JetStubElementTypes.ANONYMOUS_INITIALIZER)
-        assertEquals("initializer in STUB: class A", JetClassInitializer(initializer as PsiJetPlaceHolderStub).getDebugText())
+        assertEquals("initializer in STUB: class A", JetClassInitializer(initializer as KotlinPlaceHolderStub).getDebugText())
     }
 
     fun testClassObject() {
         val tree = createStubTree("class A { class object {} }")
         val classObject = tree.findChildStubByType(JetStubElementTypes.CLASS)!!.findChildStubByType(JetStubElementTypes.CLASS_BODY)!!
                 .findChildStubByType(JetStubElementTypes.CLASS_OBJECT)
-        assertEquals("class object in STUB: class A", JetClassObject(classObject as PsiJetPlaceHolderStub).getDebugText())
+        assertEquals("class object in STUB: class A", JetClassObject(classObject as KotlinPlaceHolderStub).getDebugText())
     }
 
     fun testPropertyAccessors() {