private static void printImports(PrintWriter out, ClassNode classNode) { List<String> imports = new ArrayList<String>(); ModuleNode moduleNode = classNode.getModule(); for (ImportNode importNode : moduleNode.getStarImports()) { imports.add(importNode.getPackageName()); } for (ImportNode imp : moduleNode.getImports()) { if (imp.getAlias() == null) imports.add(imp.getType().getName()); } imports.addAll(Arrays.asList(ResolveVisitor.DEFAULT_IMPORTS)); for (Map.Entry<String, ImportNode> entry : moduleNode.getStaticImports().entrySet()) { if (entry.getKey().equals(entry.getValue().getFieldName())) imports.add("static "+entry.getValue().getType().getName()+"."+entry.getKey()); } for (Map.Entry<String, ImportNode> entry : moduleNode.getStaticStarImports().entrySet()) { imports.add("static "+entry.getValue().getType().getName()+"."); } for (String imp : imports) { String s = ("import " + imp + ((imp.charAt(imp.length() - 1) == '.') ? "*;" : ";")) .replace('$', '.'); out.println(s); } out.println(); }
val = ((Expression) memberValue).getText(); ImportNode alias = currentModule.getStaticImports().get(val); if (alias != null) val = alias.getClassName() + "." + alias.getFieldName();
private Expression findStaticFieldOrPropAccessorImportFromModule(String name) { ModuleNode module = currentClass.getModule(); if (module == null) return null; Map<String, ImportNode> importNodes = module.getStaticImports(); Expression expression; String accessorName = getAccessorName(name);
public void visitImports(ModuleNode node) { if (node != null) { for (ImportNode importNode : node.getImports()) { visitAnnotations(importNode); importNode.visit(this); } for (ImportNode importStarNode : node.getStarImports()) { visitAnnotations(importStarNode); importStarNode.visit(this); } for (ImportNode importStaticNode : node.getStaticImports().values()) { visitAnnotations(importStaticNode); importStaticNode.visit(this); } for (ImportNode importStaticStarNode : node.getStaticStarImports().values()) { visitAnnotations(importStaticStarNode); importStaticStarNode.visit(this); } } }
private Expression transformMapEntryExpression(MapEntryExpression me, ClassNode constructorCallType) { Expression key = me.getKeyExpression(); Expression value = me.getValueExpression(); ModuleNode module = currentClass.getModule(); if (module != null && key instanceof ConstantExpression) { Map<String, ImportNode> importNodes = module.getStaticImports(); if (importNodes.containsKey(key.getText())) { ImportNode importNode = importNodes.get(key.getText()); if (importNode.getType().equals(constructorCallType)) { String newKey = importNode.getFieldName(); return new MapEntryExpression(new ConstantExpression(newKey), value.transformExpression(this)); } } } return me; }
importNode = module.getStaticImports().get(pname); if (importNode != null && importNode != currImportNode) {
for (Map.Entry<String, ImportNode> entry : ast.getStaticImports().entrySet()) { final String className = entry.getValue().getClassName(); assertStaticImportIsAllowed(entry.getKey(), className);
private Expression findStaticMethodImportFromModule(Expression method, Expression args) { ModuleNode module = currentClass.getModule(); if (module == null || !(method instanceof ConstantExpression)) return null; Map<String, ImportNode> importNodes = module.getStaticImports(); ConstantExpression ce = (ConstantExpression) method; Expression expression;
for (ImportNode importNode : module.getStaticImports().values()) { ClassNode type = importNode.getType(); if (resolve(type, true, true, true)) continue;
public void visitModuleNode(ModuleNode moduleNode) { //visit imports like import java.io.File and import java.io.File as MyFile for (ImportNode importNode : moduleNode.getImports()) { visitNode(importNode.getType()); } //visit static imports like import java.lang.Math.* for (ImportNode importNode : moduleNode.getStaticStarImports().values()) { visitNode(importNode.getType()); } //visit static imports like import java.lang.Math.cos for (ImportNode importNode : moduleNode.getStaticImports().values()) { visitNode(importNode.getType()); } for (ClassNode classNode : moduleNode.getClasses()) { if (!classNode.isScript()) { visitClass(classNode); } else { for (MethodNode method : moduleNode.getMethods()) { visitMethod(method); } } } //visit Statements that are not inside a class if (!moduleNode.getStatementBlock().isEmpty()) { visitBlockStatement(moduleNode.getStatementBlock()); } }
for (ImportNode importNode : module.getStaticImports().values()) { if (importNode.getFieldName().equals(name)) { ClassNode tmp = new ConstructedNestedClass(importNode.getType(), name);
private void addAliasOccurrences(ModuleNode moduleNode, String findingName) { for (Map.Entry<String, ImportNode> entry : moduleNode.getStaticImports().entrySet()) { if (findingName.equals(entry.getKey())) { occurrences.add(new FakeASTNode(entry.getValue().getType(), entry.getKey())); } } }
private List<ImportNode> getImportNodes(ModuleNode ast) { List<ImportNode> importNodes = new ArrayList<ImportNode>(); importNodes.addAll(ast.getImports()); importNodes.addAll(ast.getStarImports()); importNodes.addAll(ast.getStaticImports().values()); importNodes.addAll(ast.getStaticStarImports().values()); return importNodes; }
private void init() { synchronized (initializationLock) { if (!initialized) { ModuleNode ast = source.getAst(); if (ast != null) { suppressedRuleNames.addAll(getSuppressedRuleNames(ast.getPackage())); suppressedRuleNames.addAll(getSuppressedRuleNames(ast.getImports())); suppressedRuleNames.addAll(getSuppressedRuleNames(ast.getStarImports())); suppressedRuleNames.addAll(getSuppressedRuleNames(ast.getStaticImports().values())); suppressedRuleNames.addAll(getSuppressedRuleNames(ast.getStaticStarImports().values())); // if it is the only class in the file, then a @SuppressWarnings applies to everything if (ast.getClasses() != null && ast.getClasses().size() == 1) { suppressedRuleNames.addAll(getSuppressedRuleNames(ast.getClasses())); } // build up suppressions by line number suppressionsByLineNumber.putAll(getSuppressionsByLineNumber(ast)); } initialized = true; } } }
ASTNode root = path.root(); if (root instanceof ModuleNode) { for (Map.Entry<String, ImportNode> entry : ((ModuleNode) root).getStaticImports().entrySet()) { String alias = entry.getKey(); if (!alias.equals(methodCall.getMethodAsString())) {
@Override public void visitImports(ModuleNode node) { if (FindTypeUtils.isCaretOnClassNode(path, doc, cursorOffset)) { for (ImportNode importNode : node.getImports()) { addOccurrences(importNode.getType(), (ClassNode) FindTypeUtils.findCurrentNode(path, doc, cursorOffset)); } } else { // #233954 if (leaf instanceof ConstantExpression && leafParent instanceof MethodCallExpression) { addAliasOccurrences(node, ((MethodCallExpression) leafParent).getMethodAsString()); } // #234000 if (leaf instanceof VariableExpression) { addAliasOccurrences(node, ((VariableExpression) leaf).getName()); } // For both: #233954 and #234000 if (leaf instanceof BlockStatement) { for (Map.Entry<String, ImportNode> entry : node.getStaticImports().entrySet()) { OffsetRange range = ASTUtils.getNextIdentifierByName(doc, entry.getKey(), cursorOffset); if (range.containsInclusive(cursorOffset)) { occurrences.add(new FakeASTNode(entry.getValue().getType(), entry.getKey())); } } } } super.visitImports(node); }
private Expression transformMapEntryExpression(MapEntryExpression me, ClassNode constructorCallType) { Expression key = me.getKeyExpression(); Expression value = me.getValueExpression(); ModuleNode module = currentClass.getModule(); if (module != null && key instanceof ConstantExpression) { Map<String, ImportNode> importNodes = module.getStaticImports(); if (importNodes.containsKey(key.getText())) { ImportNode importNode = importNodes.get(key.getText()); if (importNode.getType().equals(constructorCallType)) { String newKey = importNode.getFieldName(); return new MapEntryExpression(new ConstantExpression(newKey), value.transformExpression(this)); } } } return me; }
public void visitImports(ModuleNode node) { if (node != null) { for (ImportNode importNode : node.getImports()) { visitAnnotations(importNode); importNode.visit(this); } for (ImportNode importStarNode : node.getStarImports()) { visitAnnotations(importStarNode); importStarNode.visit(this); } for (ImportNode importStaticNode : node.getStaticImports().values()) { visitAnnotations(importStaticNode); importStaticNode.visit(this); } for (ImportNode importStaticStarNode : node.getStaticStarImports().values()) { visitAnnotations(importStaticStarNode); importStaticStarNode.visit(this); } } }
@Override public void visit(ASTNode[] nodes, SourceUnit source) { this.sourceUnit = source; List<AnnotationNode> annotationNodes = new ArrayList<>(); ClassVisitor classVisitor = new ClassVisitor(source, annotationNodes); for (ASTNode node : nodes) { if (node instanceof ModuleNode) { ModuleNode module = (ModuleNode) node; visitAnnotatedNode(module.getPackage(), annotationNodes); for (ImportNode importNode : module.getImports()) { visitAnnotatedNode(importNode, annotationNodes); } for (ImportNode importNode : module.getStarImports()) { visitAnnotatedNode(importNode, annotationNodes); } module.getStaticImports().forEach((name, importNode) -> visitAnnotatedNode(importNode, annotationNodes)); module.getStaticStarImports().forEach((name, importNode) -> visitAnnotatedNode(importNode, annotationNodes)); for (ClassNode classNode : module.getClasses()) { visitAnnotatedNode(classNode, annotationNodes); classNode.visitContents(classVisitor); } } } processAnnotationNodes(annotationNodes); }
private Expression findStaticFieldOrPropAccessorImportFromModule(String name) { ModuleNode module = currentClass.getModule(); if (module == null) return null; Map<String, ImportNode> importNodes = module.getStaticImports(); Expression expression; String accessorName = getAccessorName(name);