azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

Browse Source
This commit is contained in:
svtk
2011-12-09 17:38:34 +04:00
parent 63d74d41af fcf14bca3a
commit 3ea077bb43
24 changed files with 272 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/META-INF/plugin.xml
+2 -2
View File
@@ -59,9 +59,9 @@
<codeInsight.overrideMethod language="jet" implementationClass="org.jetbrains.jet.plugin.codeInsight.OverrideMethodsHandler"/>
<!--
<java.elementFinder implementation="org.jetbrains.jet.plugin.java.JavaElementFinder"/>
-->
<psi.treeChangePreprocessor implementation="org.jetbrains.jet.plugin.java.JetCodeBlockModificationListener"/>
<toolWindow id="CodeWindow"
factoryClass="org.jetbrains.jet.plugin.internal.codewindow.BytecodeToolwindow$Factory"
anchor="right"/>
idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java
+2 -3
View File
@@ -17,7 +17,6 @@ import com.sun.jdi.ReferenceType;
import com.sun.jdi.request.ClassPrepareRequest;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.codegen.CodegenUtil;
import org.jetbrains.jet.codegen.GenerationState;
import org.jetbrains.jet.codegen.JetTypeMapper;
import org.jetbrains.jet.codegen.NamespaceCodegen;
@@ -113,10 +112,10 @@ public class JetPositionManager implements PositionManager {
else {
JetNamespace namespace = PsiTreeUtil.getParentOfType(sourcePosition.getElementAt(), JetNamespace.class);
if (namespace != null) {
names.add(NamespaceCodegen.getJVMClassName(CodegenUtil.getFQName(namespace)));
names.add(NamespaceCodegen.getJVMClassName(JetPsiUtil.getFQName(namespace)));
}
else {
names.add(NamespaceCodegen.getJVMClassName(CodegenUtil.getFQName(file.getRootNamespace())));
names.add(NamespaceCodegen.getJVMClassName(JetPsiUtil.getFQName(file.getRootNamespace())));
}
}
return names;
idea/src/org/jetbrains/jet/plugin/java/JavaElementFinder.java
+5 -9
View File
@@ -15,11 +15,7 @@ import com.intellij.psi.impl.file.PsiPackageImpl;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.util.SmartList;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.codegen.CodegenUtil;
import org.jetbrains.jet.lang.psi.JetClassOrObject;
import org.jetbrains.jet.lang.psi.JetDeclaration;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetNamespace;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.plugin.JetFileType;
import java.util.ArrayList;
@@ -52,7 +48,7 @@ public class JavaElementFinder extends PsiElementFinder {
final List<JetFile> filesInScope = collectProjectFiles(project, scope);
for (JetFile file : filesInScope) {
JetNamespace rootNamespace = file.getRootNamespace();
final String packageName = CodegenUtil.getFQName(rootNamespace);
final String packageName = JetPsiUtil.getFQName(rootNamespace);
if (packageName != null && qualifiedName.startsWith(packageName)) {
if (qualifiedName.equals(fqn(packageName, "namespace"))) {
answer.add(new JetLightClass(psiManager, file, "namespace"));
@@ -77,7 +73,7 @@ public class JavaElementFinder extends PsiElementFinder {
String packageFQN = psiPackage.getQualifiedName();
for (JetFile psiFile : collectProjectFiles(project, GlobalSearchScope.allScope(project))) {
final JetNamespace rootNamespace = psiFile.getRootNamespace();
if (packageFQN.equals(CodegenUtil.getFQName(rootNamespace))) {
if (packageFQN.equals(JetPsiUtil.getFQName(rootNamespace))) {
answer.add("namespace");
for (JetDeclaration declaration : rootNamespace.getDeclarations()) {
if (declaration instanceof JetClassOrObject) {
@@ -100,7 +96,7 @@ public class JavaElementFinder extends PsiElementFinder {
final List<JetFile> psiFiles = collectProjectFiles(project, GlobalSearchScope.allScope(project));
for (JetFile psiFile : psiFiles) {
if (qualifiedName.equals(CodegenUtil.getFQName(psiFile.getRootNamespace()))) {
if (qualifiedName.equals(JetPsiUtil.getFQName(psiFile.getRootNamespace()))) {
return new PsiPackageImpl(psiFile.getManager(), qualifiedName);
}
}
@@ -116,7 +112,7 @@ public class JavaElementFinder extends PsiElementFinder {
String packageFQN = psiPackage.getQualifiedName();
for (JetFile file : filesInScope) {
final JetNamespace rootNamespace = file.getRootNamespace();
if (packageFQN.equals(CodegenUtil.getFQName(rootNamespace))) {
if (packageFQN.equals(JetPsiUtil.getFQName(rootNamespace))) {
answer.add(new JetLightClass(psiManager, file, "namespace"));
for (JetDeclaration declaration : rootNamespace.getDeclarations()) {
if (declaration instanceof JetClassOrObject) {
idea/src/org/jetbrains/jet/plugin/java/JetCodeBlockModificationListener.java
+112
View File
@@ -0,0 +1,112 @@
/*
* @author max
*/
package org.jetbrains.jet.plugin.java;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.psi.*;
import com.intellij.psi.impl.PsiModificationTrackerImpl;
import com.intellij.psi.impl.PsiTreeChangeEventImpl;
import com.intellij.psi.impl.PsiTreeChangePreprocessor;
import com.intellij.psi.util.PsiModificationTracker;
import org.jetbrains.jet.lang.psi.JetBlockExpression;
import org.jetbrains.jet.lang.psi.JetClass;
import org.jetbrains.jet.lang.psi.JetFile;
public class JetCodeBlockModificationListener implements PsiTreeChangePreprocessor {
private static final Logger LOG = Logger.getInstance("#org.jetbrains.jet.plugin.java.JetCodeBlockModificationListener");
private final PsiModificationTrackerImpl myModificationTracker;
public JetCodeBlockModificationListener(final PsiModificationTracker modificationTracker) {
myModificationTracker = (PsiModificationTrackerImpl) modificationTracker;
}
@Override
public void treeChanged(final PsiTreeChangeEventImpl event) {
switch (event.getCode()) {
case BEFORE_CHILDREN_CHANGE:
case BEFORE_PROPERTY_CHANGE:
case BEFORE_CHILD_MOVEMENT:
case BEFORE_CHILD_REPLACEMENT:
case BEFORE_CHILD_ADDITION:
case BEFORE_CHILD_REMOVAL:
break;
case CHILD_ADDED:
case CHILD_REMOVED:
case CHILD_REPLACED:
processChange(event.getParent(), event.getOldChild(), event.getChild());
break;
case CHILDREN_CHANGED:
// general childrenChanged() event after each change
if (!event.isGenericChildrenChange()) {
processChange(event.getParent(), event.getParent(), null);
}
break;
case CHILD_MOVED:
case PROPERTY_CHANGED:
myModificationTracker.incCounter();
break;
default:
LOG.error("Unknown code:" + event.getCode());
break;
}
}
private void processChange(final PsiElement parent, final PsiElement child1, final PsiElement child2) {
try {
if (!isInsideCodeBlock(parent)) {
if (parent != null && parent.getContainingFile() instanceof JetFile) {
myModificationTracker.incCounter();
}
else {
myModificationTracker.incOutOfCodeBlockModificationCounter();
}
return;
}
if (containsClassesInside(child1) || child2 != child1 && containsClassesInside(child2)) {
myModificationTracker.incCounter();
}
} catch (PsiInvalidElementAccessException e) {
myModificationTracker.incCounter(); // Shall not happen actually, just a pre-release paranoia
}
}
private static boolean containsClassesInside(final PsiElement element) {
if (element == null) return false;
if (element instanceof PsiClass) return true;
PsiElement child = element.getFirstChild();
while (child != null) {
if (containsClassesInside(child)) return true;
child = child.getNextSibling();
}
return false;
}
private static boolean isInsideCodeBlock(PsiElement element) {
if (element instanceof PsiFileSystemItem) {
return false;
}
if (element == null || element.getParent() == null) return true;
PsiElement parent = element;
while (true) {
if (parent instanceof PsiFile || parent instanceof PsiDirectory || parent == null) {
return false;
}
if (parent instanceof JetClass) return false; // anonymous or local class
if (parent instanceof JetBlockExpression) {
return true;
}
parent = parent.getParent();
}
}
}
idea/src/org/jetbrains/jet/plugin/java/JetLightClass.java
+24 -10
View File
@@ -15,14 +15,18 @@ import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl;
import com.intellij.psi.impl.light.AbstractLightClass;
import com.intellij.psi.stubs.PsiClassHolderFileStub;
import com.intellij.psi.stubs.StubElement;
import com.intellij.psi.util.CachedValue;
import com.intellij.psi.util.CachedValueProvider;
import com.intellij.psi.util.CachedValuesManager;
import com.intellij.psi.util.PsiModificationTracker;
import com.intellij.util.containers.Stack;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.codegen.ClassBuilder;
import org.jetbrains.jet.codegen.ClassBuilderFactory;
import org.jetbrains.jet.codegen.CodegenUtil;
import org.jetbrains.jet.codegen.GenerationState;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetNamespace;
import org.jetbrains.jet.lang.psi.JetPsiUtil;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade;
import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
@@ -33,7 +37,7 @@ import java.util.List;
public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMarker {
private static final Logger LOG = Logger.getInstance("#org.jetbrains.jet.plugin.java.JetLightClass");
private final static Key<PsiJavaFileStub> JAVA_API_STUB = Key.create("JAVA_API_STUB");
private final static Key<CachedValue<PsiJavaFileStub>> JAVA_API_STUB = Key.create("JAVA_API_STUB");
private final JetFile file;
private final String className;
@@ -75,20 +79,30 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
return null;
}
@Override
public String getQualifiedName() {
String fqName = JetPsiUtil.getFQName(file.getRootNamespace());
return fqName.length() == 0 ? className : fqName + "." + className;
}
private PsiJavaFileStub getStub() {
PsiJavaFileStub answer = file.getUserData(JAVA_API_STUB);
CachedValue<PsiJavaFileStub> answer = file.getUserData(JAVA_API_STUB);
if (answer == null) {
answer = calcStub();
answer = CachedValuesManager.getManager(getProject()).createCachedValue(new CachedValueProvider<PsiJavaFileStub>() {
@Override
public Result<PsiJavaFileStub> compute() {
return Result.create(calcStub(), PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
}
}, false);
file.putUserData(JAVA_API_STUB, answer);
}
return answer;
return answer.getValue();
}
private PsiJavaFileStub calcStub() {
final PsiJavaFileStubImpl answer = new PsiJavaFileStubImpl(CodegenUtil.getFQName(file.getRootNamespace()), true);
final PsiJavaFileStubImpl answer = new PsiJavaFileStubImpl(JetPsiUtil.getFQName(file.getRootNamespace()), true);
final Project project = getProject();
final Stack<StubElement> stubStack = new Stack<StubElement>();
@@ -134,7 +148,7 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
finally {
final StubElement pop = stubStack.pop();
if (pop != answer) {
LOG.error("Unbalanced stack operations");
LOG.error("Unbalanced stack operations: " + pop);
}
}
}
@@ -148,5 +162,5 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
return answer;
}
}
idea/src/org/jetbrains/jet/plugin/run/JetRunConfigurationProducer.java
+3 -3
View File
@@ -8,10 +8,10 @@ import com.intellij.openapi.module.Module;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import org.jetbrains.jet.codegen.CodegenUtil;
import org.jetbrains.jet.lang.psi.JetClass;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetNamespace;
import org.jetbrains.jet.lang.psi.JetPsiUtil;
import org.jetbrains.jet.plugin.JetMainDetector;
/**
@@ -34,14 +34,14 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im
JetClass containingClass = (JetClass) location.getParentElement(JetClass.class);
if (containingClass != null && JetMainDetector.hasMain(containingClass.getDeclarations())) {
mySourceElement = containingClass;
return createConfigurationByQName(location.getModule(), configurationContext, CodegenUtil.getFQName(containingClass));
return createConfigurationByQName(location.getModule(), configurationContext, JetPsiUtil.getFQName(containingClass));
}
PsiFile psiFile = location.getPsiElement().getContainingFile();
if (psiFile instanceof JetFile) {
JetNamespace namespace = ((JetFile) psiFile).getRootNamespace();
if (JetMainDetector.hasMain(namespace.getDeclarations())) {
mySourceElement = namespace;
String fqName = CodegenUtil.getFQName(namespace);
String fqName = JetPsiUtil.getFQName(namespace);
String className = fqName.length() == 0 ? "namespace" : fqName + ".namespace";
return createConfigurationByQName(location.getModule(), configurationContext, className);
}