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(); }
@Override protected GroovyCodeVisitor getTransformer(ASTNode[] nodes, SourceUnit sourceUnit) { // todo : are there other import types that can be specified? return new AstBuilderInvocationTrap( sourceUnit.getAST().getImports(), sourceUnit.getAST().getStarImports(), sourceUnit.getSource(), sourceUnit ); }
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); } } }
grapesAliases = new HashSet<String>(); grabResolverAliases = new HashSet<String>(); for (ImportNode im : mn.getImports()) { String alias = im.getAlias(); String className = im.getClassName();
for (ImportNode importNode : ast.getImports()) { final String className = importNode.getClassName(); assertImportIsAllowed(className);
for (ImportNode importNode : module.getImports()) { currImportNode = importNode; ClassNode type = importNode.getType();
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()); } }
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 genImports(ClassNode classNode, PrintWriter out) { Set imports = new HashSet(); // // HACK: Add the default imports... since things like Closure and GroovyObject seem to parse out w/o fully qualified classnames. // imports.addAll(Arrays.asList(ResolveVisitor.DEFAULT_IMPORTS)); ModuleNode moduleNode = classNode.getModule(); for (Iterator it = moduleNode.getImportPackages().iterator(); it.hasNext();) { imports.add(it.next()); } for (Iterator it = moduleNode.getImports().iterator(); it.hasNext();) { ImportNode imp = (ImportNode) it.next(); String name = imp.getType().getName(); int lastDot = name.lastIndexOf('.'); if (lastDot != -1) imports.add(name.substring(0, lastDot + 1)); } for (Iterator it = imports.iterator(); it.hasNext();) { String imp = (String) it.next(); out.print("import "); out.print(imp); out.println("*;"); } out.println(); }
private void genImports(ClassNode classNode, PrintWriter out) { Set imports = new HashSet(); // // HACK: Add the default imports... since things like Closure and GroovyObject seem to parse out w/o fully qualified classnames. // imports.addAll(Arrays.asList(ResolveVisitor.DEFAULT_IMPORTS)); ModuleNode moduleNode = classNode.getModule(); for (Iterator it = moduleNode.getImportPackages().iterator(); it.hasNext();) { imports.add(it.next()); } for (Iterator it = moduleNode.getImports().iterator(); it.hasNext();) { ImportNode imp = (ImportNode) it.next(); String name = imp.getType().getName(); int lastDot = name.lastIndexOf('.'); if (lastDot != -1) imports.add(name.substring(0, lastDot + 1)); } for (Iterator it = imports.iterator(); it.hasNext();) { String imp = (String) it.next(); out.print("import "); out.print(imp); out.println("*;"); } out.println(); }
private void genImports(ClassNode classNode, PrintWriter out) { Set imports = new HashSet(); // // HACK: Add the default imports... since things like Closure and GroovyObject seem to parse out w/o fully qualified classnames. // imports.addAll(Arrays.asList(ResolveVisitor.DEFAULT_IMPORTS)); // FIXME by using star imports in generated class // we could cause namespace collision ModuleNode moduleNode = classNode.getModule(); for (ImportNode importNode : moduleNode.getImports()) { if (importNode.isStar()) { imports.add(importNode.getPackageName() + "."); } } for (Iterator it = moduleNode.getImports().iterator(); it.hasNext();) { ImportNode imp = (ImportNode) it.next(); String name = imp.getType().getName(); int lastDot = name.lastIndexOf('.'); if (lastDot != -1) { imports.add(name.substring(0, lastDot + 1)); } } for (Iterator it = imports.iterator(); it.hasNext();) { String imp = (String) it.next(); out.print("import "); out.print(imp); out.println("*;"); } out.println(); }
@Override public void visitImports(ModuleNode node) { for (ImportNode importNode : node.getImports()) { imports.add(importNode.getType().getNameWithoutPackage()); } super.visitImports(node); } }
private List<String> getImportedTypes() { List<String> importedTypes = new ArrayList<>(); ModuleNode moduleNode = ContextHelper.getSurroundingModuleNode(context); if (moduleNode != null) { // this gets the list of full-qualified names of imports. for (ImportNode importNode : moduleNode.getImports()) { importedTypes.add(importNode.getClassName()); } // this returns a list of String's of wildcard-like included types. for (ImportNode wildcardImport : moduleNode.getStarImports()) { importedTypes.add(wildcardImport.getPackageName()); } } return importedTypes; }
private 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 (String imp : imports) { String s = new StringBuilder() .append("import ") .append(imp) .append((imp.charAt(imp.length() - 1) == '.') ? "*;" : ";") .toString() .replace('$', '.'); out.println(s); } out.println(); }
private 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 (String imp : imports) { String s = new StringBuilder() .append("import ") .append(imp) .append((imp.charAt(imp.length() - 1) == '.') ? "*;" : ";") .toString() .replace('$', '.'); out.println(s); } out.println(); }
private static ClassNode getCurrentImportNode(ModuleNode moduleNode, BaseDocument doc, int caret) { for (ImportNode importNode : moduleNode.getImports()) { if (isCaretOnImportStatement(importNode, doc, caret)) { if (!importNode.isStar()) { return ElementUtils.getType(importNode); } } } return null; }
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; } } }
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 void visitModule(ModuleNode module) { for (ClassNode classNode : module.getClasses()) { AnnotationNode annotation = new AnnotationNode(new ClassNode(Grab.class)); annotation.addMember("value", new ConstantExpression("groovy")); classNode.addAnnotation(annotation); // We only need to do it at most once break; } // Disable the addition of a static initializer that calls Grape.addResolver // because all the dependencies are local now disableGrabResolvers(module.getClasses()); disableGrabResolvers(module.getImports()); }