From 7b34e2cd184aa823b88051511c4acf1260f3a7f5 Mon Sep 17 00:00:00 2001 From: Dmitry Batkovich Date: Fri, 16 Dec 2016 16:18:38 +0300 Subject: [PATCH 1/7] javac ast indices: get rid of private java compiler API except Name#toUtf() --- .../jps/javac/ast/Javac8RefScanner.java | 7 +- .../BackwardReferenceIndexWriter.java | 7 +- .../ast/JavacReferenceCollectorListener.java | 209 +++++++++++------- .../jps/javac/ast/JavacTreeRefScanner.java | 76 +++---- .../jps/javac/ast/JavacTreeScannerSink.java | 12 +- .../jps/javac/ast/api/JavacFileData.java | 36 ++- .../jetbrains/jps/javac/ast/api/JavacRef.java | 110 +++++---- .../packageInfo2/initialIndex.txt | 7 + .../packageInfo2/myPackage/package-info.java | 2 + .../references/ReferenceIndexTest.kt | 4 + 10 files changed, 277 insertions(+), 193 deletions(-) create mode 100644 jps/jps-builders/testData/referencesIndex/packageInfo2/initialIndex.txt create mode 100644 jps/jps-builders/testData/referencesIndex/packageInfo2/myPackage/package-info.java diff --git a/jps/javac-ref-scanner-8/src/org/jetbrains/jps/javac/ast/Javac8RefScanner.java b/jps/javac-ref-scanner-8/src/org/jetbrains/jps/javac/ast/Javac8RefScanner.java index d774f7f1daaa..69c61be01785 100644 --- a/jps/javac-ref-scanner-8/src/org/jetbrains/jps/javac/ast/Javac8RefScanner.java +++ b/jps/javac-ref-scanner-8/src/org/jetbrains/jps/javac/ast/Javac8RefScanner.java @@ -7,7 +7,6 @@ import com.sun.tools.javac.code.Symbol; import com.sun.tools.javac.code.Type; import com.sun.tools.javac.tree.JCTree; import org.jetbrains.jps.javac.ast.api.JavacDef; -import org.jetbrains.jps.javac.ast.api.JavacRef; /** * Used via reflection in {@link JavacTreeRefScanner#createASTScanner()} @@ -20,7 +19,7 @@ public class Javac8RefScanner extends JavacTreeRefScanner { final Type type = lambda.type; final Symbol.TypeSymbol symbol = type.asElement(); if (symbol != null) { - sink.sinkDeclaration(new JavacDef.JavacFunExprDef(JavacRef.JavacSymbolRefBase.fromSymbol(symbol))); + sink.sinkDeclaration(new JavacDef.JavacFunExprDef(sink.asJavacRef(symbol))); } return super.visitLambdaExpression(node, sink); } @@ -30,8 +29,8 @@ public class Javac8RefScanner extends JavacTreeRefScanner { JCTree.JCMemberReference memberRef = (JCTree.JCMemberReference)node; final Symbol sym = memberRef.sym; if (sym != null) { - sink.sinkReference(JavacRef.JavacSymbolRefBase.fromSymbol(sym)); - sink.sinkDeclaration(new JavacDef.JavacFunExprDef(JavacRef.JavacSymbolRefBase.fromSymbol(memberRef.type.asElement()))); + sink.sinkReference(sink.asJavacRef(sym)); + sink.sinkDeclaration(new JavacDef.JavacFunExprDef(sink.asJavacRef(memberRef.type.asElement()))); } return super.visitMemberReference(node, sink); } diff --git a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java index 395a67e62d2d..1b0495bc9078 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java +++ b/jps/jps-builders/src/org/jetbrains/jps/backwardRefs/BackwardReferenceIndexWriter.java @@ -17,7 +17,6 @@ package org.jetbrains.jps.backwardRefs; import com.intellij.util.SystemProperties; import com.intellij.util.indexing.InvertedIndex; -import com.sun.tools.javac.code.Flags; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.backwardRefs.index.CompiledFileData; @@ -31,12 +30,11 @@ import org.jetbrains.jps.incremental.storage.BuildDataManager; import org.jetbrains.jps.javac.ast.api.JavacRef; import org.jetbrains.jps.model.java.compiler.JavaCompilers; +import javax.lang.model.element.Modifier; import java.io.File; import java.io.IOException; import java.util.Collection; -import static com.sun.tools.javac.code.Flags.PRIVATE; - public class BackwardReferenceIndexWriter { public static final String PROP_KEY = "jps.backward.ref.index.builder"; @@ -152,9 +150,8 @@ public class BackwardReferenceIndexWriter { return null; } - //see Symbol.isPrivate() method private static boolean isPrivate(JavacRef ref) { - return (ref.getFlags() & Flags.AccessFlags) == PRIVATE; + return ref.getModifiers().contains(Modifier.PRIVATE); } private static int id(JavacRef ref, ByteArrayEnumerator byteArrayEnumerator) { diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacReferenceCollectorListener.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacReferenceCollectorListener.java index 0231eb25ab84..8fa0b011935c 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacReferenceCollectorListener.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacReferenceCollectorListener.java @@ -15,24 +15,26 @@ */ package org.jetbrains.jps.javac.ast; +import com.intellij.openapi.util.NotNullLazyValue; import com.intellij.util.Consumer; import com.intellij.util.ReflectionUtil; -import com.sun.source.util.JavacTask; -import com.sun.source.util.TaskEvent; -import com.sun.source.util.TaskListener; -import com.sun.tools.javac.code.Symbol; -import com.sun.tools.javac.tree.JCTree; +import com.sun.source.tree.*; +import com.sun.source.util.*; import com.sun.tools.javac.util.ClientCodeException; -import com.sun.tools.javac.util.Name; import gnu.trove.THashMap; import gnu.trove.THashSet; import gnu.trove.TObjectHashingStrategy; +import org.jetbrains.annotations.NotNull; import org.jetbrains.jps.javac.ast.api.JavacDef; import org.jetbrains.jps.javac.ast.api.JavacFileData; import org.jetbrains.jps.javac.ast.api.JavacRef; +import javax.lang.model.element.Element; import javax.lang.model.element.ElementKind; +import javax.lang.model.element.Name; import javax.lang.model.element.TypeElement; +import javax.lang.model.util.Elements; +import javax.lang.model.util.Types; import javax.tools.*; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; @@ -42,8 +44,17 @@ final class JavacReferenceCollectorListener implements TaskListener { private final boolean myDivideImportRefs; private final Consumer myDataConsumer; private final JavacTreeRefScanner myAstScanner; + private final Elements myElementUtility; + private final Types myTypeUtility; + private final Trees myTreeUtility; - private Name myAsterisk; + private NotNullLazyValue myAsterisk = new NotNullLazyValue() { + @NotNull + @Override + protected Name compute() { + return myElementUtility.getName("*"); + } + }; private final Map myIncompletelyProcessedFiles = new THashMap(10); @@ -52,7 +63,11 @@ final class JavacReferenceCollectorListener implements TaskListener { Consumer dataConsumer) { JavacTask javacTask = (JavacTask)task; Method addTaskMethod = ReflectionUtil.getMethod(JavacTask.class, "addTaskListener", TaskListener.class); // jdk >= 8 - final JavacReferenceCollectorListener taskListener = new JavacReferenceCollectorListener(divideImportRefs, dataConsumer); + final JavacReferenceCollectorListener taskListener = new JavacReferenceCollectorListener(divideImportRefs, + dataConsumer, + javacTask.getElements(), + javacTask.getTypes(), + Trees.instance(javacTask)); if (addTaskMethod != null) { try { addTaskMethod.invoke(task, taskListener); @@ -69,9 +84,16 @@ final class JavacReferenceCollectorListener implements TaskListener { } } - private JavacReferenceCollectorListener(boolean divideImportRefs, Consumer dataConsumer) { + private JavacReferenceCollectorListener(boolean divideImportRefs, + Consumer dataConsumer, + Elements elementUtility, + Types typeUtility, + Trees treeUtility) { myDivideImportRefs = divideImportRefs; myDataConsumer = dataConsumer; + myElementUtility = elementUtility; + myTypeUtility = typeUtility; + myTreeUtility = treeUtility; myAstScanner = JavacTreeRefScanner.createASTScanner(); } @@ -85,59 +107,49 @@ final class JavacReferenceCollectorListener implements TaskListener { try { if (e.getKind() == TaskEvent.Kind.ANALYZE) { // javac creates an event on each processed top level declared class not file - final JCTree.JCCompilationUnit unit = (JCTree.JCCompilationUnit)e.getCompilationUnit(); + final CompilationUnitTree unit = e.getCompilationUnit(); final String fileName = e.getSourceFile().getName(); - final List declarations = unit.getTypeDecls(); - final int size = declarations.size(); - boolean isFileDataComplete = true; - boolean collectImportsData = true; - JCTree declarationToProcess = null; - final TypeElement analyzedElement = e.getTypeElement(); + Tree declarationToProcess = myTreeUtility.getTree(e.getTypeElement()); - IncompletelyProcessedFile incompletelyProcessedFile; - switch (size) { - case 0: - incompletelyProcessedFile = new IncompletelyProcessedFile(0, fileName); - break; - case 1: - incompletelyProcessedFile = new IncompletelyProcessedFile(0, fileName); - declarationToProcess = declarations.get(0); - break; - default: - incompletelyProcessedFile = myIncompletelyProcessedFiles.get(fileName); - if (incompletelyProcessedFile == null) { - myIncompletelyProcessedFiles.put(fileName, incompletelyProcessedFile = new IncompletelyProcessedFile(size, fileName)); - } else { - collectImportsData = false; - } + boolean collectImportsData; + boolean addedToCache = true; + IncompletelyProcessedFile incompletelyProcessedFile = myIncompletelyProcessedFiles.get(fileName); + if (incompletelyProcessedFile == null) { + final int declarationCount = unit.getTypeDecls().size(); + incompletelyProcessedFile = new IncompletelyProcessedFile(declarationCount, fileName, unit); + if (declarationCount == 1 && declarationToProcess != null) { + addedToCache = false; + } else { + myIncompletelyProcessedFiles.put(fileName, incompletelyProcessedFile); + } + collectImportsData = true; + } + else { + collectImportsData = false; + } - if (incompletelyProcessedFile.decrementRemainDeclarationsAndGet() == 0) { - myIncompletelyProcessedFiles.remove(fileName); - } else { - isFileDataComplete = false; - } - - for (JCTree declaration : declarations) { - if (declaration.type != null && declaration.type.tsym == analyzedElement) { - declarationToProcess = declaration; - break; - } - } - - if (declarationToProcess == null) throw new IllegalStateException("Can't find tree for " + analyzedElement.getQualifiedName()); + final boolean isFileDataComplete; + if (incompletelyProcessedFile.decrementRemainDeclarationsAndGet(declarationToProcess) == 0) { + if (addedToCache) { + myIncompletelyProcessedFiles.remove(fileName); + } + isFileDataComplete = true; + } + else { + isFileDataComplete = false; } if (collectImportsData) { - scanImports(unit, incompletelyProcessedFile.myFileData.getRefs()); + scanImports(unit, incompletelyProcessedFile.myFileData.getRefs(), incompletelyProcessedFile.getTreeHelper()); if (myDivideImportRefs) { - scanImports(unit, incompletelyProcessedFile.myFileData.getImportRefs()); + scanImports(unit, incompletelyProcessedFile.myFileData.getImportRefs(), incompletelyProcessedFile.getTreeHelper()); } } final IncompletelyProcessedFile finalIncompletelyProcessedFile = incompletelyProcessedFile; JavacTreeScannerSink sink = new JavacTreeScannerSink() { @Override - public void sinkReference(JavacRef.JavacSymbolRefBase ref) { + public void sinkReference(JavacRef.JavacElementRefBase ref) { finalIncompletelyProcessedFile.myFileData.getRefs().add(ref); } @@ -145,11 +157,27 @@ final class JavacReferenceCollectorListener implements TaskListener { public void sinkDeclaration(JavacDef def) { finalIncompletelyProcessedFile.myFileData.getDefs().add(def); } + + @Override + public JavacRef.JavacElementRefBase asJavacRef(Element element) { + return JavacRef.JavacElementRefBase.fromElement(element, myElementUtility); + } + + @Override + public Element getReferencedElement(Tree tree) { + return finalIncompletelyProcessedFile.getTreeHelper().getReferencedElement(tree); + } + + @Override + public Types getTypeUtility() { + return myTypeUtility; + } + }; myAstScanner.scan(declarationToProcess, sink); if (isFileDataComplete) { - for (JCTree.JCAnnotation annotation : unit.getPackageAnnotations()) { + for (AnnotationTree annotation : unit.getPackageAnnotations()) { myAstScanner.scan(annotation, sink); } @@ -162,62 +190,65 @@ final class JavacReferenceCollectorListener implements TaskListener { } } - private Name getAsteriskFromCurrentNameTable(Name tableRepresentative) { - if (myAsterisk == null) { - myAsterisk = tableRepresentative.table.fromChars(new char[]{'*'}, 0, 1); - } - return myAsterisk; - } - - private void scanImports(JCTree.JCCompilationUnit compilationUnit, Collection symbols) { - for (JCTree.JCImport anImport : compilationUnit.getImports()) { - final JCTree.JCFieldAccess id = (JCTree.JCFieldAccess)anImport.getQualifiedIdentifier(); - final Symbol sym = id.sym; - if (sym == null) { - final JCTree.JCExpression qExpr = id.getExpression(); - if (qExpr instanceof JCTree.JCFieldAccess) { - final JCTree.JCFieldAccess classImport = (JCTree.JCFieldAccess)qExpr; - final Symbol ownerSym = classImport.sym; + private void scanImports(CompilationUnitTree compilationUnit, + Collection elements, + JavacTreeHelper treeHelper) { + for (ImportTree anImport : compilationUnit.getImports()) { + final MemberSelectTree id = (MemberSelectTree)anImport.getQualifiedIdentifier(); + final Element element = treeHelper.getReferencedElement(id); + if (element == null) { + final ExpressionTree qExpr = id.getExpression(); + if (qExpr instanceof MemberSelectTree) { + final MemberSelectTree classImport = (MemberSelectTree)qExpr; + final Element ownerElement = treeHelper.getReferencedElement(classImport); final Name name = id.getIdentifier(); - if (name != getAsteriskFromCurrentNameTable(name)) { + if (name != myAsterisk.getValue()) { // member import - for (Symbol memberSymbol : ownerSym.members().getElements()) { - if (memberSymbol.getSimpleName() == name) { - symbols.add(JavacRef.JavacSymbolRefBase.fromSymbol(memberSymbol)); + for (Element memberElement : myElementUtility.getAllMembers((TypeElement)ownerElement)) { + if (memberElement.getSimpleName() == name) { + elements.add(JavacRef.JavacElementRefBase.fromElement(memberElement, myElementUtility)); } } } - collectClassImports(ownerSym, symbols); + collectClassImports(ownerElement, elements); } } else { // class import - collectClassImports(sym, symbols); + collectClassImports(element, elements); } } } - private static void collectClassImports(Symbol baseImport, Collection collector) { - for (Symbol symbol = baseImport; - symbol != null && symbol.getKind() != ElementKind.PACKAGE; - symbol = symbol.owner) { - collector.add(JavacRef.JavacSymbolRefBase.fromSymbol(symbol)); + private void collectClassImports(Element baseImport, Collection collector) { + for (Element element = baseImport; + element != null && element.getKind() != ElementKind.PACKAGE; + element = element.getEnclosingElement()) { + collector.add(JavacRef.JavacElementRefBase.fromElement(element, myElementUtility)); } } private class IncompletelyProcessedFile { private final JavacFileData myFileData; + private final JavacTreeHelper myTreeHelper; private int myRemainDeclarations; - private IncompletelyProcessedFile(int remainDeclarations, String filePath) { + private IncompletelyProcessedFile(int remainDeclarations, + String filePath, + CompilationUnitTree unitTree) { myRemainDeclarations = remainDeclarations; myFileData = new JavacFileData(filePath, createReferenceHolder(), myDivideImportRefs ? createReferenceHolder() : Collections.emptyList(), createDefinitionHolder()); + myTreeHelper = new JavacTreeHelper(unitTree, myTreeUtility); } - private int decrementRemainDeclarationsAndGet() { - return --myRemainDeclarations; + private int decrementRemainDeclarationsAndGet(Tree declarationToProcess) { + return declarationToProcess == null ? myRemainDeclarations : --myRemainDeclarations; + } + + private JavacTreeHelper getTreeHelper() { + return myTreeHelper; } } @@ -225,12 +256,12 @@ final class JavacReferenceCollectorListener implements TaskListener { return new THashSet(new TObjectHashingStrategy() { @Override public int computeHashCode(JavacRef ref) { - return ((JavacRef.JavacSymbolRefBase) ref).getOriginalElement().hashCode(); + return ((JavacRef.JavacElementRefBase) ref).getOriginalElement().hashCode(); } @Override public boolean equals(JavacRef r1, JavacRef r2) { - return ((JavacRef.JavacSymbolRefBase) r1).getOriginalElement() == ((JavacRef.JavacSymbolRefBase) r2).getOriginalElement(); + return ((JavacRef.JavacElementRefBase) r1).getOriginalElement() == ((JavacRef.JavacElementRefBase) r2).getOriginalElement(); } }); } @@ -238,4 +269,18 @@ final class JavacReferenceCollectorListener implements TaskListener { private static List createDefinitionHolder() { return new ArrayList(); } + + private static class JavacTreeHelper { + private final TreePath myUnitPath; + private final Trees myTreeUtil; + + private JavacTreeHelper(CompilationUnitTree unit, Trees treeUtil) { + myUnitPath = new TreePath(unit); + myTreeUtil = treeUtil; + } + + private Element getReferencedElement(Tree tree) { + return myTreeUtil.getElement(new TreePath(myUnitPath, tree)); + } + } } diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeRefScanner.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeRefScanner.java index 19e3ba0d28fa..c9e9eeff1af3 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeRefScanner.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeRefScanner.java @@ -17,17 +17,28 @@ package org.jetbrains.jps.javac.ast; import com.sun.source.tree.*; import com.sun.source.util.TreeScanner; -import com.sun.tools.javac.code.Symbol; -import com.sun.tools.javac.code.Type; -import com.sun.tools.javac.tree.JCTree; -import com.sun.tools.javac.util.List; import org.jetbrains.jps.javac.ast.api.JavacDef; import org.jetbrains.jps.javac.ast.api.JavacRef; +import javax.lang.model.element.Element; import javax.lang.model.element.ElementKind; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.TypeKind; +import javax.lang.model.type.TypeMirror; +import java.util.EnumSet; +import java.util.List; +import java.util.Set; class JavacTreeRefScanner extends TreeScanner { + private static final Set ALLOWED_ELEMENTS = EnumSet.of(ElementKind.ENUM, + ElementKind.CLASS, + ElementKind.ANNOTATION_TYPE, + ElementKind.INTERFACE, + ElementKind.ENUM_CONSTANT, + ElementKind.FIELD, + ElementKind.CONSTRUCTOR, + ElementKind.METHOD); + @Override public Tree visitCompilationUnit(CompilationUnitTree node, JavacTreeScannerSink sink) { scan(node.getPackageAnnotations(), sink); @@ -37,49 +48,39 @@ class JavacTreeRefScanner extends TreeScanner { @Override public Tree visitIdentifier(IdentifierTree node, JavacTreeScannerSink sink) { - final JCTree.JCIdent javacIdentifier = (JCTree.JCIdent)node; - final Type type = javacIdentifier.type; - if (type == null) { + final Element element = sink.getReferencedElement(node); + if (element == null) { return null; } - if (type.getKind() == TypeKind.PACKAGE) { - return null; + if (ALLOWED_ELEMENTS.contains(element.getKind())) { + sink.sinkReference(sink.asJavacRef(element)); } - final Symbol sym = javacIdentifier.sym; - if (sym == null || - sym.getKind() == ElementKind.PARAMETER || - sym.getKind() == ElementKind.LOCAL_VARIABLE || - sym.getKind() == ElementKind.EXCEPTION_PARAMETER || - sym.getKind() == ElementKind.TYPE_PARAMETER) { - return null; - } - sink.sinkReference(JavacRef.JavacSymbolRefBase.fromSymbol(sym)); return null; } @Override public Tree visitVariable(VariableTree node, JavacTreeScannerSink sink) { - final Symbol.VarSymbol sym = ((JCTree.JCVariableDecl)node).sym; - if (sym != null && sym.getKind() == ElementKind.FIELD) { - sink.sinkReference(JavacRef.JavacSymbolRefBase.fromSymbol(sym)); + final Element element = sink.getReferencedElement(node); + if (element != null && element.getKind() == ElementKind.FIELD) { + sink.sinkReference(sink.asJavacRef(element)); } return super.visitVariable(node, sink); } @Override public Tree visitMemberSelect(MemberSelectTree node, JavacTreeScannerSink sink) { - final Symbol sym = ((JCTree.JCFieldAccess)node).sym; - if (sym != null && sym.getKind() != ElementKind.PACKAGE) { - sink.sinkReference(JavacRef.JavacSymbolRefBase.fromSymbol(sym)); + final Element element = sink.getReferencedElement(node); + if (element != null && element.getKind() != ElementKind.PACKAGE) { + sink.sinkReference(sink.asJavacRef(element)); } return super.visitMemberSelect(node, sink); } @Override public Tree visitMethod(MethodTree node, JavacTreeScannerSink sink) { - final Symbol.MethodSymbol sym = ((JCTree.JCMethodDecl)node).sym; - if (sym != null) { - sink.sinkReference(JavacRef.JavacSymbolRefBase.fromSymbol(sym)); + final Element element = sink.getReferencedElement(node); + if (element != null) { + sink.sinkReference(sink.asJavacRef(element)); } return super.visitMethod(node, sink); } @@ -87,25 +88,26 @@ class JavacTreeRefScanner extends TreeScanner { @Override public Tree visitClass(ClassTree node, JavacTreeScannerSink sink) { - JCTree.JCClassDecl classDecl = (JCTree.JCClassDecl)node; - Symbol.ClassSymbol sym = classDecl.sym; - if (sym == null) return null; + TypeElement element = (TypeElement)sink.getReferencedElement(node); + if (element == null) return null; - final Type superclass = sym.getSuperclass(); - final List interfaces = sym.getInterfaces(); + final TypeMirror superclass = element.getSuperclass(); + final List interfaces = element.getInterfaces(); final JavacRef[] supers; - if (superclass != Type.noType) { + if (superclass != sink.getTypeUtility().getNoType(TypeKind.NONE)) { supers = new JavacRef[interfaces.size() + 1]; - supers[interfaces.size()] = JavacRef.JavacSymbolRefBase.fromSymbol(superclass.asElement()); + supers[interfaces.size()] = sink.asJavacRef(sink.getTypeUtility().asElement(superclass)); + } else { supers = interfaces.isEmpty() ? JavacRef.EMPTY_ARRAY : new JavacRef[interfaces.size()]; } int i = 0; - for (Type anInterface : interfaces) { - supers[i++] = JavacRef.JavacSymbolRefBase.fromSymbol(anInterface.asElement()); + for (TypeMirror anInterface : interfaces) { + supers[i++] = sink.asJavacRef(sink.getTypeUtility().asElement(anInterface)); + } - final JavacRef.JavacSymbolRefBase aClass = JavacRef.JavacSymbolRefBase.fromSymbol(sym); + final JavacRef.JavacElementRefBase aClass = sink.asJavacRef(element); sink.sinkReference(aClass); sink.sinkDeclaration(new JavacDef.JavacClassDef(aClass, supers)); diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeScannerSink.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeScannerSink.java index 04569efe57e7..f5224b6f8dd4 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeScannerSink.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/JavacTreeScannerSink.java @@ -15,12 +15,22 @@ */ package org.jetbrains.jps.javac.ast; +import com.sun.source.tree.Tree; import org.jetbrains.jps.javac.ast.api.JavacDef; import org.jetbrains.jps.javac.ast.api.JavacRef; +import javax.lang.model.element.Element; +import javax.lang.model.util.Types; + interface JavacTreeScannerSink { - void sinkReference(JavacRef.JavacSymbolRefBase ref); + void sinkReference(JavacRef.JavacElementRefBase ref); void sinkDeclaration(JavacDef def); + + JavacRef.JavacElementRefBase asJavacRef(Element element); + + Element getReferencedElement(Tree tree); + + Types getTypeUtility(); } diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java index 364cf25b0b85..a5c0dc572d4b 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java @@ -19,12 +19,14 @@ import com.intellij.openapi.util.ThrowableComputable; import com.intellij.openapi.util.io.BufferExposingByteArrayOutputStream; import com.intellij.util.ThrowableConsumer; import com.intellij.util.io.*; -import com.intellij.util.io.DataOutputStream; import org.jetbrains.annotations.NotNull; -import java.io.*; -import java.util.Collection; -import java.util.List; +import javax.lang.model.element.Modifier; +import java.io.DataInput; +import java.io.DataInputStream; +import java.io.DataOutput; +import java.io.IOException; +import java.util.*; public class JavacFileData { private final String myFilePath; @@ -212,7 +214,7 @@ public class JavacFileData { } else { throw new IllegalStateException("unknown type: " + ref.getClass()); } - out.writeLong(ref.getFlags()); + writeModifiers(out, ref.getModifiers()); writeBytes(out, ref.getName()); } @@ -221,11 +223,11 @@ public class JavacFileData { final byte marker = in.readByte(); switch (marker) { case CLASS_MARKER: - return new JavacRef.JavacClassImpl(in.readBoolean(), in.readLong(), readBytes(in)); + return new JavacRef.JavacClassImpl(in.readBoolean(), readModifiers(in), readBytes(in)); case METHOD_MARKER: - return new JavacRef.JavacMethodImpl(readBytes(in), in.readByte(), in.readLong(), readBytes(in)); + return new JavacRef.JavacMethodImpl(readBytes(in), in.readByte(), readModifiers(in), readBytes(in)); case FIELD_MARKER: - return new JavacRef.JavacFieldImpl(readBytes(in), in.readLong(), readBytes(in)); + return new JavacRef.JavacFieldImpl(readBytes(in), readModifiers(in), readBytes(in)); default: throw new IllegalStateException("unknown marker " + marker); } @@ -242,6 +244,24 @@ public class JavacFileData { in.readFully(buf); return buf; } + + private void writeModifiers(final DataOutput output, Set modifiers) throws IOException { + DataInputOutputUtil.writeSeq(output, modifiers, new ThrowableConsumer() { + @Override + public void consume(Modifier modifier) throws IOException { + IOUtil.writeUTF(output, modifier.name()); + } + }); + } + + private Set readModifiers(final DataInput input) throws IOException { + return EnumSet.copyOf(DataInputOutputUtil.readSeq(input, new ThrowableComputable() { + @Override + public Modifier compute() throws IOException { + return null; + } + })); + } }; } } diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacRef.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacRef.java index a7c532cfb3dc..cb1228c5105e 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacRef.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacRef.java @@ -15,17 +15,20 @@ */ package org.jetbrains.jps.javac.ast.api; -import com.sun.tools.javac.code.Symbol; -import com.sun.tools.javac.util.Convert; +import com.sun.tools.javac.util.Name; import org.jetbrains.annotations.NotNull; +import javax.lang.model.element.*; +import javax.lang.model.util.Elements; +import java.util.Set; + public interface JavacRef { JavacRef[] EMPTY_ARRAY = new JavacRef[0]; @NotNull byte[] getName(); - long getFlags(); + Set getModifiers(); @NotNull byte[] getOwnerName(); @@ -43,11 +46,11 @@ public interface JavacRef { abstract class JavacRefBase implements JavacRef { private final byte[] myName; - private final long myFlags; + private final Set myModifiers; - protected JavacRefBase(byte[] name, long flags) { + protected JavacRefBase(byte[] name, Set modifiers) { myName = name; - myFlags = flags; + myModifiers = modifiers; } @NotNull @@ -57,16 +60,16 @@ public interface JavacRef { } @Override - public final long getFlags() { - return myFlags; + public final Set getModifiers() { + return myModifiers; } } class JavacClassImpl extends JavacRefBase implements JavacClass { private boolean myAnonymous; - public JavacClassImpl(boolean anonymous, long flags, byte[] name) { - super(name, flags); + public JavacClassImpl(boolean anonymous, Set modifiers, byte[] name) { + super(name, modifiers); myAnonymous = anonymous; } @@ -79,19 +82,14 @@ public interface JavacRef { public boolean isAnonymous() { return myAnonymous; } - - @Override - public String toString() { - return Convert.utf2string(getName()); - } } class JavacMethodImpl extends JavacRefBase implements JavacMethod { private final byte[] myOwnerName; private final byte myParamCount; - public JavacMethodImpl(byte[] ownerName, byte paramCount, long flags, byte[] name) { - super(name, flags); + public JavacMethodImpl(byte[] ownerName, byte paramCount, Set modifiers, byte[] name) { + super(name, modifiers); myOwnerName = ownerName; myParamCount = paramCount; } @@ -105,18 +103,13 @@ public interface JavacRef { public byte[] getOwnerName() { return myOwnerName; } - - @Override - public String toString() { - return Convert.utf2string(getOwnerName()) + "." + Convert.utf2string(getName()) + "(" + myParamCount + ")"; - } } class JavacFieldImpl extends JavacRefBase implements JavacField { private final byte[] myOwnerName; - public JavacFieldImpl(byte[] ownerName, long flags, byte[] name) { - super(name, flags); + public JavacFieldImpl(byte[] ownerName, Set modifiers, byte[] name) { + super(name, modifiers); myOwnerName = ownerName; } @@ -125,79 +118,84 @@ public interface JavacRef { public byte[] getOwnerName() { return myOwnerName; } - - @Override - public String toString() { - return Convert.utf2string(getOwnerName()) + "." + Convert.utf2string(getName()); - } } - abstract class JavacSymbolRefBase implements JavacRef { - protected final @NotNull Symbol myOriginalElement; + abstract class JavacElementRefBase implements JavacRef { + protected final @NotNull Element myOriginalElement; + protected final Elements myElementUtility; - protected JavacSymbolRefBase(@NotNull Symbol element) {myOriginalElement = element;} + protected JavacElementRefBase(@NotNull Element element, Elements elementUtility) { + myOriginalElement = element; + myElementUtility = elementUtility; + } @NotNull - public Symbol getOriginalElement() { + public Element getOriginalElement() { return myOriginalElement; } @NotNull @Override public byte[] getName() { - return myOriginalElement.flatName().toUtf(); + return ((Name) myOriginalElement.getSimpleName()).toUtf(); } @Override - public long getFlags() { - return myOriginalElement.flags(); + public Set getModifiers() { + return myOriginalElement.getModifiers(); } @NotNull @Override public byte[] getOwnerName() { - return myOriginalElement.owner.flatName().toUtf(); + return ((Name) myElementUtility.getBinaryName(((TypeElement) myOriginalElement.getEnclosingElement()))).toUtf(); } - public static JavacRef.JavacSymbolRefBase fromSymbol(Symbol symbol) { - if (symbol instanceof Symbol.ClassSymbol) { - return new JavacRef.JavacSymbolClassImpl(symbol); + public static JavacElementRefBase fromElement(Element element, Elements elementUtility) { + if (element instanceof TypeElement) { + return new JavacElementClassImpl(element, elementUtility); } - else if (symbol instanceof Symbol.VarSymbol) { - return new JavacRef.JavacSymbolFieldImpl(symbol); + else if (element instanceof VariableElement) { + return new JavacElementFieldImpl(element, elementUtility); } - else if (symbol instanceof Symbol.MethodSymbol) { - return new JavacRef.JavacSymbolMethodImpl(symbol); + else if (element instanceof ExecutableElement) { + return new JavacElementMethodImpl(element, elementUtility); } - throw new AssertionError("unexpected symbol: " + symbol + " class: " + symbol.getClass()); + throw new AssertionError("unexpected element: " + element + " class: " + element.getClass()); } } - class JavacSymbolClassImpl extends JavacSymbolRefBase implements JavacClass { - public JavacSymbolClassImpl(@NotNull Symbol element) { - super(element); + class JavacElementClassImpl extends JavacElementRefBase implements JavacClass { + public JavacElementClassImpl(@NotNull Element element, Elements elementUtility) { + super(element, elementUtility); + } + + @NotNull + @Override + public byte[] getName() { + return ((Name) myElementUtility.getBinaryName(((TypeElement) myOriginalElement))).toUtf(); } @Override public boolean isAnonymous() { - return myOriginalElement.name.isEmpty(); + return ((Name) myOriginalElement.getSimpleName()).isEmpty(); } } - class JavacSymbolMethodImpl extends JavacSymbolRefBase implements JavacMethod { - public JavacSymbolMethodImpl(@NotNull Symbol element) { - super(element); + class JavacElementMethodImpl extends JavacElementRefBase implements JavacMethod { + public JavacElementMethodImpl(@NotNull Element element, Elements elementUtility) { + super(element, elementUtility); } @Override public byte getParamCount() { - return (byte)((Symbol.MethodSymbol)myOriginalElement).type.getParameterTypes().size(); + return (byte)((ExecutableElement)myOriginalElement).getParameters().size(); } } - class JavacSymbolFieldImpl extends JavacSymbolRefBase implements JavacField { - public JavacSymbolFieldImpl(@NotNull Symbol element) { - super(element); + class JavacElementFieldImpl extends JavacElementRefBase implements JavacField { + public JavacElementFieldImpl(@NotNull Element element, Elements elementUtility) { + super(element, elementUtility); } } } diff --git a/jps/jps-builders/testData/referencesIndex/packageInfo2/initialIndex.txt b/jps/jps-builders/testData/referencesIndex/packageInfo2/initialIndex.txt new file mode 100644 index 000000000000..924d8b108579 --- /dev/null +++ b/jps/jps-builders/testData/referencesIndex/packageInfo2/initialIndex.txt @@ -0,0 +1,7 @@ +Backward Hierarchy: + + +Backward References: +java.lang.Deprecated in package-info + +Class Definitions: \ No newline at end of file diff --git a/jps/jps-builders/testData/referencesIndex/packageInfo2/myPackage/package-info.java b/jps/jps-builders/testData/referencesIndex/packageInfo2/myPackage/package-info.java new file mode 100644 index 000000000000..3f5236e3ebc3 --- /dev/null +++ b/jps/jps-builders/testData/referencesIndex/packageInfo2/myPackage/package-info.java @@ -0,0 +1,2 @@ +@Deprecated +package myPackage; \ No newline at end of file diff --git a/jps/jps-builders/testSrc/org/jetbrains/references/ReferenceIndexTest.kt b/jps/jps-builders/testSrc/org/jetbrains/references/ReferenceIndexTest.kt index 13d667071be9..1ad0c467c67c 100644 --- a/jps/jps-builders/testSrc/org/jetbrains/references/ReferenceIndexTest.kt +++ b/jps/jps-builders/testSrc/org/jetbrains/references/ReferenceIndexTest.kt @@ -78,6 +78,10 @@ class ReferenceIndexTest : ReferenceIndexTestBase() { assertIndexOnRebuild("myPackage/package-info.java") } + fun testPackageInfo2() { + assertIndexOnRebuild("myPackage/package-info.java") + } + fun testArrayRefs() { assertIndexOnRebuild("Array.java", "Foo.java", "Bar.java") } From dd8438e990930d67178312640418043e5c72ebcb Mon Sep 17 00:00:00 2001 From: Dmitry Batkovich Date: Fri, 16 Dec 2016 16:20:01 +0300 Subject: [PATCH 2/7] javac ast indices: fix javac data serialization --- .../src/org/jetbrains/jps/javac/ast/api/JavacFileData.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java index a5c0dc572d4b..6fb81e630d3a 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java +++ b/jps/jps-builders/src/org/jetbrains/jps/javac/ast/api/JavacFileData.java @@ -258,7 +258,7 @@ public class JavacFileData { return EnumSet.copyOf(DataInputOutputUtil.readSeq(input, new ThrowableComputable() { @Override public Modifier compute() throws IOException { - return null; + return Modifier.valueOf(IOUtil.readUTF(input)); } })); } From 853bbd5e93a6d3c58d6e10be6ea8cfbec490cf75 Mon Sep 17 00:00:00 2001 From: Dmitry Batkovich Date: Fri, 16 Dec 2016 16:20:40 +0300 Subject: [PATCH 3/7] fix compilation --- .../com/intellij/compiler/CompilerReferencesFindUsagesTest.java | 2 -- .../com/intellij/compiler/CompilerReferencesTestBase.java | 2 -- 2 files changed, 4 deletions(-) diff --git a/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesFindUsagesTest.java b/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesFindUsagesTest.java index 3b78c4196f45..46b1776dd016 100644 --- a/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesFindUsagesTest.java +++ b/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesFindUsagesTest.java @@ -35,7 +35,6 @@ public class CompilerReferencesFindUsagesTest extends DaemonAnalyzerTestCase { public void setUp() throws Exception { myDefaultEnableState = CompilerReferenceService.IS_ENABLED_KEY.asBoolean(); CompilerReferenceService.IS_ENABLED_KEY.setValue(true); - CompilerReferenceService.enabledInTests = true; super.setUp(); myCompilerTester = new CompilerTester(myModule); } @@ -44,7 +43,6 @@ public class CompilerReferencesFindUsagesTest extends DaemonAnalyzerTestCase { public void tearDown() throws Exception { try { CompilerReferenceService.IS_ENABLED_KEY.setValue(myDefaultEnableState); - CompilerReferenceService.enabledInTests = false; myCompilerTester.tearDown(); } finally { diff --git a/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesTestBase.java b/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesTestBase.java index f61f1fd0652e..0fd0bde00891 100644 --- a/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesTestBase.java +++ b/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesTestBase.java @@ -24,14 +24,12 @@ public abstract class CompilerReferencesTestBase extends AbstractCompilerAwareTe public void setUp() throws Exception { myDefaultEnableState = CompilerReferenceService.IS_ENABLED_KEY.asBoolean(); CompilerReferenceService.IS_ENABLED_KEY.setValue(true); - CompilerReferenceService.enabledInTests = true; super.setUp(); } @Override public void tearDown() throws Exception { CompilerReferenceService.IS_ENABLED_KEY.setValue(myDefaultEnableState); - CompilerReferenceService.enabledInTests = false; super.tearDown(); } } From d978c37af66551f2c15d413eb5881a4cd9bdf1e2 Mon Sep 17 00:00:00 2001 From: Sergey Simonchik Date: Fri, 16 Dec 2016 16:16:54 +0300 Subject: [PATCH 4/7] runnerw: remove eclipse project settings --- native/runner/runnerw/.cproject | 930 ------------------ native/runner/runnerw/.project | 71 -- .../org.eclipse.cdt.managedbuilder.core.prefs | 14 - .../org.eclipse.core.resources.prefs | 3 - 4 files changed, 1018 deletions(-) delete mode 100644 native/runner/runnerw/.cproject delete mode 100644 native/runner/runnerw/.project delete mode 100644 native/runner/runnerw/.settings/org.eclipse.cdt.managedbuilder.core.prefs delete mode 100644 native/runner/runnerw/.settings/org.eclipse.core.resources.prefs diff --git a/native/runner/runnerw/.cproject b/native/runner/runnerw/.cproject deleted file mode 100644 index 88d813ccca94..000000000000 --- a/native/runner/runnerw/.cproject +++ /dev/null @@ -1,930 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/native/runner/runnerw/.project b/native/runner/runnerw/.project deleted file mode 100644 index cc8212c4e102..000000000000 --- a/native/runner/runnerw/.project +++ /dev/null @@ -1,71 +0,0 @@ - - - runnerw - - - - - - org.eclipse.cdt.managedbuilder.core.genmakebuilder - clean,full,incremental, - - - ?name? - - - - org.eclipse.cdt.make.core.append_environment - true - - - org.eclipse.cdt.make.core.buildArguments - - - - org.eclipse.cdt.make.core.buildCommand - make - - - org.eclipse.cdt.make.core.buildLocation - ${workspace_loc:/ctrl/Debug} - - - org.eclipse.cdt.make.core.contents - org.eclipse.cdt.make.core.activeConfigSettings - - - org.eclipse.cdt.make.core.enableAutoBuild - false - - - org.eclipse.cdt.make.core.enableCleanBuild - true - - - org.eclipse.cdt.make.core.enableFullBuild - true - - - org.eclipse.cdt.make.core.stopOnError - true - - - org.eclipse.cdt.make.core.useDefaultBuildCmd - true - - - - - org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder - full,incremental, - - - - - - org.eclipse.cdt.core.cnature - org.eclipse.cdt.core.ccnature - org.eclipse.cdt.managedbuilder.core.managedBuildNature - org.eclipse.cdt.managedbuilder.core.ScannerConfigNature - - diff --git a/native/runner/runnerw/.settings/org.eclipse.cdt.managedbuilder.core.prefs b/native/runner/runnerw/.settings/org.eclipse.cdt.managedbuilder.core.prefs deleted file mode 100644 index 0f163f721d5d..000000000000 --- a/native/runner/runnerw/.settings/org.eclipse.cdt.managedbuilder.core.prefs +++ /dev/null @@ -1,14 +0,0 @@ -#Fri Jul 16 15:25:34 MSD 2010 -eclipse.preferences.version=1 -environment/buildEnvironmentInclude/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/CPATH/delimiter=; -environment/buildEnvironmentInclude/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/CPATH/operation=remove -environment/buildEnvironmentInclude/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/CPLUS_INCLUDE_PATH/delimiter=; -environment/buildEnvironmentInclude/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/CPLUS_INCLUDE_PATH/operation=remove -environment/buildEnvironmentInclude/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/C_INCLUDE_PATH/delimiter=; -environment/buildEnvironmentInclude/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/C_INCLUDE_PATH/operation=remove -environment/buildEnvironmentInclude/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/append=true -environment/buildEnvironmentInclude/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/appendContributed=true -environment/buildEnvironmentLibrary/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/LIBRARY_PATH/delimiter=; -environment/buildEnvironmentLibrary/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/LIBRARY_PATH/operation=remove -environment/buildEnvironmentLibrary/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/append=true -environment/buildEnvironmentLibrary/cdt.managedbuild.config.gnu.mingw.exe.debug.997820937/appendContributed=true diff --git a/native/runner/runnerw/.settings/org.eclipse.core.resources.prefs b/native/runner/runnerw/.settings/org.eclipse.core.resources.prefs deleted file mode 100644 index a3fdc8b23f2d..000000000000 --- a/native/runner/runnerw/.settings/org.eclipse.core.resources.prefs +++ /dev/null @@ -1,3 +0,0 @@ -#Sat Jul 17 17:27:10 MSD 2010 -eclipse.preferences.version=1 -encoding/runnerw.cpp=Cp1251 From be229a094c0c7134246234aabb5c7b535bf517f1 Mon Sep 17 00:00:00 2001 From: Anton Tarasov Date: Fri, 16 Dec 2016 16:16:18 +0300 Subject: [PATCH 5/7] IDEA-165448 [hidpi-jdk] windows: sized text "floats" under kbd cursor on 200% scale --- .../openapi/editor/impl/FontInfo.java | 21 +++++++++++++++++++ .../editor/impl/view/SimpleTextFragment.java | 4 ++-- 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/FontInfo.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/FontInfo.java index a51886db9f80..ce64c02f88e9 100644 --- a/platform/platform-impl/src/com/intellij/openapi/editor/impl/FontInfo.java +++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/FontInfo.java @@ -19,13 +19,17 @@ import com.intellij.Patches; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.ex.util.EditorUIUtil; import com.intellij.openapi.editor.impl.view.FontLayoutService; +import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.registry.Registry; +import com.intellij.util.ReflectionUtil; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.ui.UIUtil; import gnu.trove.TIntHashSet; import org.intellij.lang.annotations.JdkConstants; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import sun.font.FontStrike; +import sun.font.FontUtilities; import java.awt.*; import java.awt.font.FontRenderContext; @@ -34,6 +38,7 @@ import java.awt.font.TextAttribute; import java.awt.image.BufferedImage; import java.io.File; import java.io.FilenameFilter; +import java.lang.reflect.Method; import java.util.*; import java.util.List; @@ -46,6 +51,8 @@ public class FontInfo { private static final boolean USE_ALTERNATIVE_CAN_DISPLAY_PROCEDURE = Registry.is("ide.mac.fix.font.fallback"); private static final FontRenderContext DUMMY_CONTEXT = new FontRenderContext(null, false, false); + private static Ref getCodePointAdvanceRef; + private final TIntHashSet mySymbolsToBreakDrawingIteration = new TIntHashSet(); private final Font myFont; @@ -231,6 +238,20 @@ public class FontInfo { return FontLayoutService.getInstance().charWidth(metrics, codePoint); } + public float charWidth2D(int codePoint) { + if (getCodePointAdvanceRef == null) { + getCodePointAdvanceRef = new Ref<>(ReflectionUtil.getDeclaredMethod(FontStrike.class, "getCodePointAdvance", int.class)); + } + if (getCodePointAdvanceRef.get() != null) { + try { + FontStrike fs = FontUtilities.getFont2D(myFont).getStrike(myFont, myFontMetrics.getFontRenderContext()); + return (float)getCodePointAdvanceRef.get().invoke(fs, codePoint); + } + catch (Exception ignore) {} + } + return charWidth(codePoint); + } + public FontMetrics fontMetrics() { if (myFontMetrics == null) { // We need to use antialising-aware font metrics because we've alrady encountered a situation when non-antialiased symbol diff --git a/platform/platform-impl/src/com/intellij/openapi/editor/impl/view/SimpleTextFragment.java b/platform/platform-impl/src/com/intellij/openapi/editor/impl/view/SimpleTextFragment.java index 4454c1167d71..cd47c50aa035 100644 --- a/platform/platform-impl/src/com/intellij/openapi/editor/impl/view/SimpleTextFragment.java +++ b/platform/platform-impl/src/com/intellij/openapi/editor/impl/view/SimpleTextFragment.java @@ -36,7 +36,7 @@ class SimpleTextFragment extends TextFragment { myFont = fontInfo.getFont(); float x = 0; for (int i = 0; i < myText.length; i++) { - x += fontInfo.charWidth(myText[i]); + x += fontInfo.charWidth2D(myText[i]); myCharPositions[i] = x; } } @@ -54,7 +54,7 @@ class SimpleTextFragment extends TextFragment { @Override public void draw(Graphics2D g, float x, float y, int startColumn, int endColumn) { g.setFont(myFont); - g.drawChars(myText, startColumn, endColumn - startColumn, (int)x, (int)y); + g.drawString(new String(myText, startColumn, endColumn - startColumn), x, y); } @Override From 427c7266bb5875a48804b40846a141b646999d28 Mon Sep 17 00:00:00 2001 From: Ekaterina Tuzova Date: Fri, 16 Dec 2016 16:33:32 +0300 Subject: [PATCH 6/7] do not create sdk if project generation failed --- .../python/newProject/steps/PythonGenerateProjectCallback.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/python-community-configure/src/com/jetbrains/python/newProject/steps/PythonGenerateProjectCallback.java b/python/python-community-configure/src/com/jetbrains/python/newProject/steps/PythonGenerateProjectCallback.java index c615e7a1e30a..4a18e043b9e0 100644 --- a/python/python-community-configure/src/com/jetbrains/python/newProject/steps/PythonGenerateProjectCallback.java +++ b/python/python-community-configure/src/com/jetbrains/python/newProject/steps/PythonGenerateProjectCallback.java @@ -72,7 +72,7 @@ public class PythonGenerateProjectCallback implements NullableConsumer Date: Fri, 16 Dec 2016 16:35:15 +0300 Subject: [PATCH 7/7] do not login twice --- .../edu/learning/checker/StudyCheckTask.java | 4 +++- .../learning/stepic/EduStepicAuthorizedClient.java | 10 ++++++---- .../edu/learning/stepic/EduStepicConnector.java | 13 +++++++++---- .../jetbrains/edu/learning/stepic/LoginDialog.java | 2 +- 4 files changed, 19 insertions(+), 10 deletions(-) diff --git a/python/educational-core/student/src/com/jetbrains/edu/learning/checker/StudyCheckTask.java b/python/educational-core/student/src/com/jetbrains/edu/learning/checker/StudyCheckTask.java index 84b3f6168ce7..bb51a047753a 100644 --- a/python/educational-core/student/src/com/jetbrains/edu/learning/checker/StudyCheckTask.java +++ b/python/educational-core/student/src/com/jetbrains/edu/learning/checker/StudyCheckTask.java @@ -104,7 +104,9 @@ public class StudyCheckTask extends com.intellij.openapi.progress.Task.Backgroun runAfterTaskCheckedActions(); final Course course = StudyTaskManager.getInstance(myProject).getCourse(); if (course != null && EduNames.STUDY.equals(course.getCourseMode())) { - EduStepicConnector.postSolution(myTask, testsOutput.isSuccess(), myProject); + if (StudyTaskManager.getInstance(myProject).getUser().getAccessToken() != null) { + EduStepicConnector.postSolution(myTask, testsOutput.isSuccess(), myProject); + } } } } diff --git a/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/EduStepicAuthorizedClient.java b/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/EduStepicAuthorizedClient.java index d4bfa7d10cd1..c197c91e7f32 100644 --- a/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/EduStepicAuthorizedClient.java +++ b/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/EduStepicAuthorizedClient.java @@ -10,6 +10,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.util.net.HttpConfigurable; import com.intellij.util.net.ssl.CertificateManager; import com.jetbrains.edu.learning.StudyTaskManager; +import com.jetbrains.edu.learning.StudyUtils; import org.apache.http.*; import org.apache.http.client.entity.UrlEncodedFormEntity; import org.apache.http.client.methods.CloseableHttpResponse; @@ -78,10 +79,7 @@ public class EduStepicAuthorizedClient { } ourClient = initializeClient(stepicUser); if (ourClient == null) { - final StepicUser user = login(stepicUser); - if (user != null) { - ourClient = initializeClient(stepicUser); - } + ourClient = EduStepicClient.getHttpClient(); } return ourClient; } @@ -106,6 +104,10 @@ public class EduStepicAuthorizedClient { else { final StepicUser authorizedUser = login(stepicUser); if (authorizedUser != null) { + final Project project = StudyUtils.getStudyProject(); + if (project != null) { + StudyTaskManager.getInstance(project).setUser(authorizedUser); + } return initializeClient(authorizedUser); } } diff --git a/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/EduStepicConnector.java b/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/EduStepicConnector.java index 963864e11e72..c457392ab0aa 100644 --- a/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/EduStepicConnector.java +++ b/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/EduStepicConnector.java @@ -2,6 +2,7 @@ package com.jetbrains.edu.learning.stepic; import com.google.gson.Gson; import com.google.gson.GsonBuilder; +import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.Document; import com.intellij.openapi.fileEditor.FileDocumentManager; @@ -313,6 +314,7 @@ public class EduStepicConnector { try { final String response = postAttempt(project, task.getStepId()); + if (response.isEmpty()) return; final StepicWrappers.AttemptWrapper.Attempt attempt = new Gson().fromJson(response, StepicWrappers.AttemptContainer.class).attempts.get(0); final Map taskFiles = task.getTaskFiles(); @@ -326,10 +328,12 @@ public class EduStepicConnector { final String fileName = fileEntry.name; final VirtualFile virtualFile = taskDir.findFileByRelativePath(fileName); if (virtualFile != null) { - final Document document = FileDocumentManager.getInstance().getDocument(virtualFile); - if (document != null) { - files.add(new StepicWrappers.SolutionFile(fileName, document.getCharsSequence().toString())); - } + ApplicationManager.getApplication().runReadAction(() -> { + final Document document = FileDocumentManager.getInstance().getDocument(virtualFile); + if (document != null) { + files.add(new StepicWrappers.SolutionFile(fileName, document.getCharsSequence().toString())); + } + }); } } @@ -342,6 +346,7 @@ public class EduStepicConnector { public static String postAttempt(@NotNull Project project, int id) throws IOException { final CloseableHttpClient client = EduStepicAuthorizedClient.getHttpClient(project); + if (StudyTaskManager.getInstance(project).getUser().getAccessToken() == null) return ""; final HttpPost attemptRequest = new HttpPost(EduStepicNames.STEPIC_API_URL + EduStepicNames.ATTEMPTS); String attemptRequestBody = new Gson().toJson(new StepicWrappers.AttemptWrapper(id)); attemptRequest.setEntity(new StringEntity(attemptRequestBody, ContentType.APPLICATION_JSON)); diff --git a/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/LoginDialog.java b/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/LoginDialog.java index 15a3c65e07bb..270f73031dcb 100644 --- a/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/LoginDialog.java +++ b/python/educational-core/student/src/com/jetbrains/edu/learning/stepic/LoginDialog.java @@ -43,7 +43,7 @@ public class LoginDialog extends DialogWrapper { protected void doOKAction() { if (!validateLoginAndPasswordFields()) return; myStepicUser = EduStepicAuthorizedClient.login(myLoginPanel.getLogin(), myLoginPanel.getPassword()); - if (myStepicUser != null) { + if (myStepicUser != null && myStepicUser.getId() > 0 && myStepicUser.getAccessToken() != null) { doJustOkAction(); } else {