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

breakpoints for multi-file namespaces

Browse Source
This commit is contained in:
Alex Tkachman
2012-06-22 11:55:16 +03:00
parent 1ae1f13821
commit c1802e2360
7 changed files with 132 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java
+26
View File
@@ -16,6 +16,7 @@
package org.jetbrains.jet.codegen;
import com.intellij.openapi.util.Pair;
import com.intellij.util.containers.MultiMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -47,6 +48,7 @@ public class ClosureAnnotator {
private final Map<DeclarationDescriptor, ClassDescriptorImpl> classesForFunctions = new HashMap<DeclarationDescriptor, ClassDescriptorImpl>();
private final Map<DeclarationDescriptor,ClassDescriptor> enclosing = new HashMap<DeclarationDescriptor, ClassDescriptor>();
private final MultiMap<FqName, JetFile> namespaceName2MultiNamespaceFiles = MultiMap.create();
private final MultiMap<FqName, JetFile> namespaceName2Files = MultiMap.create();
private BindingContext bindingContext;
@@ -165,9 +167,33 @@ public class ClosureAnnotator {
for (JetFile jetFile : entry.getValue()) {
jetFile.accept(visitor);
}
ArrayList<JetFile> namespaceFiles = new ArrayList<JetFile>();
for (JetFile jetFile : entry.getValue()) {
ArrayList<JetDeclaration> fileFunctions = new ArrayList<JetDeclaration>();
for (JetDeclaration declaration : jetFile.getDeclarations()) {
if (declaration instanceof JetNamedFunction) {
fileFunctions.add(declaration);
}
}
if (fileFunctions.size() > 0) {
namespaceFiles.add(jetFile);
}
}
if(namespaceFiles.size() > 1) {
for (JetFile namespaceFile : namespaceFiles) {
namespaceName2MultiNamespaceFiles.putValue(entry.getKey(), namespaceFile);
}
}
}
}
public boolean isMultiFileNamespace(FqName fqName) {
return namespaceName2MultiNamespaceFiles.get(fqName).size() > 0;
}
public JvmClassName classNameForAnonymousClass(JetElement expression) {
if (expression instanceof JetObjectLiteralExpression) {
JetObjectLiteralExpression jetObjectLiteralExpression = (JetObjectLiteralExpression) expression;
compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java
+4 -15
View File
@@ -81,20 +81,7 @@ public class NamespaceCodegen {
}
public void generate(CompilationErrorHandler errorHandler, final Progress progress) {
ArrayList<Pair<JetFile, Collection<JetDeclaration>>> byFile = new ArrayList<Pair<JetFile, Collection<JetDeclaration>>>();
for (JetFile file : files) {
ArrayList<JetDeclaration> fileFunctions = new ArrayList<JetDeclaration>();
for (JetDeclaration declaration : file.getDeclarations()) {
if (declaration instanceof JetNamedFunction) {
fileFunctions.add(declaration);
}
}
if (fileFunctions.size() > 0)
byFile.add(new Pair<JetFile, Collection<JetDeclaration>>(file, fileFunctions));
}
boolean multiFile = byFile.size() > 1;
boolean multiFile = state.getInjector().getClosureAnnotator().isMultiFileNamespace(name);
for (JetFile file : files) {
VirtualFile vFile = file.getVirtualFile();
@@ -165,7 +152,9 @@ public class NamespaceCodegen {
if (k > 0) {
PsiFile containingFile = file.getContainingFile();
String className = name.child(Name.identifier("namespace$src$" + (nextMultiFile++))).getFqName().replace('.','/');
String fname = containingFile.getName();
fname = fname.substring(0,fname.lastIndexOf('.'));
String className = name.child(Name.identifier("namespace$src$" + fname)).getFqName().replace('.','/');
ClassBuilder builder = state.forNamespacepart(className, file);
builder.defineClass(containingFile, V1_6,
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetFilesProvider.java
+38
View File
@@ -19,13 +19,20 @@
*/
package org.jetbrains.jet.lang.resolve.java;
import com.google.common.base.Predicate;
import com.intellij.openapi.components.ServiceManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.UserDataHolder;
import com.intellij.openapi.util.UserDataHolderBase;
import com.intellij.psi.PsiFile;
import com.intellij.psi.search.GlobalSearchScope;
import com.intellij.util.Function;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetPsiUtil;
import org.jetbrains.jet.lang.resolve.name.FqName;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
public abstract class JetFilesProvider {
@@ -33,6 +40,37 @@ public abstract class JetFilesProvider {
return ServiceManager.getService(project, JetFilesProvider.class);
}
public final Function<JetFile, List<JetFile>> allNamespaceFiles() {
return new Function<JetFile, List<JetFile>>() {
@Override
public List<JetFile> fun(JetFile file) {
return new SameJetFilePredicate(file).filter(sampleToAllFilesInModule().fun(file));
}
};
}
public abstract Function<JetFile, Collection<JetFile>> sampleToAllFilesInModule();
public abstract List<JetFile> allInScope(GlobalSearchScope scope);
public static class SameJetFilePredicate implements Predicate<PsiFile> {
private final FqName name;
public SameJetFilePredicate(JetFile file) {
this.name = JetPsiUtil.getFQName(file);
}
@Override
public boolean apply(PsiFile psiFile) {
return JetPsiUtil.getFQName((JetFile) psiFile).equals(name);
}
public List<JetFile> filter(Collection<JetFile> allFiles) {
LinkedList<JetFile> files = new LinkedList<JetFile>();
for (JetFile aFile : allFiles) {
if(apply(aFile))
files.add(aFile);
}
return files;
}
}
}
compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzerFacadeForEverything.java
+3
View File
@@ -34,6 +34,9 @@ import java.util.List;
*/
public class AnalyzerFacadeForEverything {
private AnalyzerFacadeForEverything() {
}
public static AnalyzeExhaust analyzeBodiesInFilesWithJavaIntegration(
Project project, List<AnalyzerScriptParameter> scriptParameters, Predicate<PsiFile> filesToAnalyzeCompletely,
@NotNull BindingTrace traceContext,
compiler/tests/org/jetbrains/jet/codegen/CodegenTestFiles.java
+3
View File
@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.ref.JetTypeName;
import org.jetbrains.jet.parsing.JetParsingTest;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.regex.Matcher;
@@ -93,6 +94,8 @@ public class CodegenTestFiles {
for (String name : names) {
try {
String content = JetTestUtils.doLoadFile(JetParsingTest.getTestDataDir() + "/codegen/", name);
int i = name.lastIndexOf(File.separatorChar);
name = name.substring(i+1);
JetFile file = (JetFile) JetTestUtils.createFile(name, content, project);
files.add(file);
} catch (IOException e) {
idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java
+51 -14
View File
@@ -28,11 +28,12 @@ import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.search.FilenameIndex;
import com.intellij.psi.search.ProjectScope;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.psi.util.*;
import com.sun.jdi.AbsentInformationException;
import com.sun.jdi.Location;
import com.sun.jdi.ReferenceType;
import com.sun.jdi.request.ClassPrepareRequest;
import com.sun.jna.TypeMapper;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
@@ -42,17 +43,20 @@ import org.jetbrains.jet.di.InjectorForJetTypeMapper;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
import org.jetbrains.jet.lang.resolve.java.JvmClassName;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
import java.util.*;
/**
* @author yole
* @author alex.tkachman
*/
public class JetPositionManager implements PositionManager {
private final DebugProcess myDebugProcess;
private WeakHashMap<PsiFile, JetTypeMapper> myTypeMappers = new WeakHashMap<PsiFile, JetTypeMapper>();
private WeakHashMap<FqName, CachedValue<JetTypeMapper>> myTypeMappers = new WeakHashMap<FqName, CachedValue<JetTypeMapper>>();
public JetPositionManager(DebugProcess debugProcess) {
myDebugProcess = debugProcess;
@@ -132,7 +136,7 @@ public class JetPositionManager implements PositionManager {
final JetFile file = (JetFile)sourcePosition.getFile();
JetTypeMapper typeMapper = prepareTypeMapper(file);
PsiElement psiElement = PsiTreeUtil.getParentOfType(sourcePosition.getElementAt(), JetClassOrObject.class, JetFunctionLiteralExpression.class);
PsiElement psiElement = PsiTreeUtil.getParentOfType(sourcePosition.getElementAt(), JetClassOrObject.class, JetFunctionLiteralExpression.class, JetNamedFunction.class);
if (psiElement == null) {
JetFile namespace = PsiTreeUtil.getParentOfType(sourcePosition.getElementAt(), JetFile.class);
if (namespace != null) {
@@ -143,8 +147,31 @@ public class JetPositionManager implements PositionManager {
}
}
else {
if (psiElement instanceof JetClassOrObject)
if (psiElement instanceof JetClassOrObject) {
names.addAll(typeMapper.allJvmNames((JetClassOrObject) psiElement));
}
else if(psiElement instanceof JetNamedFunction) {
if(psiElement.getParent() instanceof JetFile) {
JetFile namespace = PsiTreeUtil.getParentOfType(sourcePosition.getElementAt(), JetFile.class);
boolean multiFileNamespace = typeMapper.getClosureAnnotator().isMultiFileNamespace(JetPsiUtil.getFQName(namespace));
if(multiFileNamespace) {
String name = namespace.getName();
names.add(NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(namespace)).getInternalName() + "$src$" + name.substring(0,name.lastIndexOf('.')));
}
else {
names.add(NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(namespace)).getInternalName());
}
}
else {
JetFile namespace = PsiTreeUtil.getParentOfType(sourcePosition.getElementAt(), JetFile.class);
if (namespace != null) {
names.add(NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(namespace)).getInternalName());
}
else {
names.add(NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(file)).getInternalName());
}
}
}
else {
names.add(typeMapper.getClosureAnnotator().classNameForAnonymousClass((JetElement) psiElement).getInternalName());
}
@@ -155,17 +182,27 @@ public class JetPositionManager implements PositionManager {
return names;
}
private JetTypeMapper prepareTypeMapper(JetFile file) {
final JetTypeMapper mapper = myTypeMappers.get(file);
if (mapper != null) {
return mapper;
private JetTypeMapper prepareTypeMapper(final JetFile file) {
FqName fqName = JetPsiUtil.getFQName(file);
CachedValue<JetTypeMapper> value = myTypeMappers.get(fqName);
if(value == null) {
value = CachedValuesManager.getManager(file.getProject()).createCachedValue(new CachedValueProvider<JetTypeMapper>() {
@Override
public Result<JetTypeMapper> compute() {
final AnalyzeExhaust analyzeExhaust = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile(file);
analyzeExhaust.throwIfError();
List<JetFile> namespaceFiles = JetFilesProvider.getInstance(file.getProject()).allNamespaceFiles().fun(file);
JetTypeMapper typeMapper = new InjectorForJetTypeMapper(analyzeExhaust.getBindingContext(), namespaceFiles).getJetTypeMapper();
typeMapper.getClosureAnnotator().init();
return new Result<JetTypeMapper>(typeMapper, PsiModificationTracker.MODIFICATION_COUNT);
}
}, false);
myTypeMappers.put(fqName, value);
}
final AnalyzeExhaust analyzeExhaust = WholeProjectAnalyzerFacade.analyzeProjectWithCacheOnAFile(file);
analyzeExhaust.throwIfError();
JetTypeMapper typeMapper = new InjectorForJetTypeMapper(
analyzeExhaust.getBindingContext(), Collections.singletonList(file)).getJetTypeMapper();
myTypeMappers.put(file, typeMapper);
return typeMapper;
return value.getValue();
}
@NotNull
idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java
+7 -2
View File
@@ -16,6 +16,7 @@
package org.jetbrains.jet.plugin.project;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.progress.ProcessCanceledException;
@@ -29,14 +30,18 @@ import com.intellij.psi.util.CachedValuesManager;
import com.intellij.psi.util.PsiModificationTracker;
import com.intellij.util.Function;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
import org.jetbrains.jet.lang.diagnostics.Errors;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetPsiUtil;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
import org.jetbrains.jet.lang.resolve.BodiesResolveContext;
import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
import org.jetbrains.jet.lang.resolve.name.FqName;
import java.util.Collection;
import java.util.Collections;
@@ -91,11 +96,11 @@ public final class AnalyzerFacadeWithCache {
BodiesResolveContext context = analyzeExhaustHeaders.getBodiesResolveContext();
assert context != null : "Headers resolver should prepare and stored information for bodies resolve";
// Need to resolve bodies in given file
// Need to resolve bodies in given file and all in the same package
AnalyzeExhaust exhaust = AnalyzerFacadeProvider.getAnalyzerFacadeForFile(file).analyzeBodiesInFiles(
file.getProject(),
Collections.<AnalyzerScriptParameter>emptyList(),
Predicates.<PsiFile>equalTo(file),
new JetFilesProvider.SameJetFilePredicate(file),
new DelegatingBindingTrace(analyzeExhaustHeaders.getBindingContext()),
context);