/** * @return a list of all the classes in each module in the compilation unit */ public List getClasses() { List<ClassNode> answer = new ArrayList<ClassNode>(); for (ModuleNode module : modules) { answer.addAll(module.getClasses()); } return answer; }
/** * Convenience routine to get the first ClassNode, for * when you are sure there is only one. */ public ClassNode getFirstClassNode() { return this.ast.getModules().get(0).getClasses().get(0); }
public void addModule(ModuleNode node) { // node==null means a compilation error prevented // groovy from building an ast if (node == null) return; modules.add(node); node.setUnit(this); addClasses(node.getClasses()); }
public void sortClasses(){ if (isEmpty()) return; List<ClassNode> classes = getClasses(); LinkedList<ClassNode> sorted = new LinkedList<ClassNode>(); int level=1; while (!classes.isEmpty()) { for (Iterator<ClassNode> cni = classes.iterator(); cni.hasNext();) { ClassNode cn = cni.next(); ClassNode sn = cn; for (int i=0; sn!=null && i<level; i++) sn = sn.getSuperClass(); if (sn!=null && sn.isPrimaryClassNode()) continue; cni.remove(); sorted.addLast(cn); } level++; } this.classes = sorted; }
private ClassNode getSourceUnitClass(VariableExpression ve) { List<ClassNode> classes = source.getAST().getClasses(); for (ClassNode classNode : classes) { if (classNode.getNameWithoutPackage().equals(ve.getName())) return classNode; } return null; }
/** * Lookup a ClassNode by its name from the source unit * * @param type the name of the class whose ClassNode we want to lookup * @return a ClassNode representing the class */ public ClassNode lookupClassNodeFor(String type) { for (ClassNode cn : typeCheckingVisitor.getSourceUnit().getAST().getClasses()) { if (cn.getName().equals(type)) return cn; } return null; }
private boolean helperClassNotCreatedYet(final ClassNode traitReceiver) { return !traitReceiver.redirect().getInnerClasses().hasNext() && this.unit.getAST().getClasses().contains(traitReceiver.redirect()); } private boolean isTraitSuperPropertyExpression(Expression exp) {
private List<ClassNode> getPrimaryClassNodes(boolean sort) { List<ClassNode> unsorted = new ArrayList<ClassNode>(); for (ModuleNode module : this.ast.getModules()) { unsorted.addAll(module.getClasses()); } if (!sort) return unsorted; int unsortedSize = unsorted.size(); int[] indexClass = new int[unsortedSize]; int[] indexInterface = new int[unsortedSize]; { int i = 0; for (Iterator<ClassNode> iter = unsorted.iterator(); iter.hasNext(); i++) { ClassNode element = iter.next(); if (element.isInterface()) { indexInterface[i] = getSuperInterfaceCount(element); indexClass[i] = -1; } else { indexClass[i] = getSuperClassCount(element); indexInterface[i] = -1; } } } List<ClassNode> sorted = getSorted(indexInterface, unsorted); sorted.addAll(getSorted(indexClass, unsorted)); return sorted; }
private void resolveHelperClassIfNecessary(final ClassNode helperClassNode) { if (helperClassNode == null) { return; } for (ClassNode cNode : unit.getAST().getClasses()) { ClassNode unresolvedHelperNode = cNode.getNodeMetaData(UNRESOLVED_HELPER_CLASS); if (unresolvedHelperNode != null && unresolvedHelperNode.getName().equals(helperClassNode.getName())) { unresolvedHelperNode.setRedirect(helperClassNode); } } }
public void call(SourceUnit source) throws CompilationFailedException { List<ClassNode> classes = source.ast.getClasses(); for (ClassNode node : classes) { VariableScopeVisitor scopeVisitor = new VariableScopeVisitor(source); scopeVisitor.visitClass(node); resolveVisitor.setClassNodeResolver(classNodeResolver); resolveVisitor.startResolving(node, source); } } };
@SuppressWarnings("unchecked") private void indexAstNodes() { visitor.visitBlockStatement(module.getStatementBlock()); for (MethodNode method : module.getMethods()) visitor.visitMethod(method); for (ClassNode clazz : module.getClasses()) visitor.visitClass(clazz); }
void visit(ASTNode[] nodes, SourceUnit sourceUnit) { ErrorReporter errorReporter = new ErrorReporter(sourceUnit); SourceLookup sourceLookup = new SourceLookup(sourceUnit); try { ModuleNode module = (ModuleNode) nodes[0]; @SuppressWarnings("unchecked") List<ClassNode> classes = module.getClasses(); for (ClassNode clazz : classes) if (isSpec(clazz)) processSpec(clazz, errorReporter, sourceLookup); } finally { sourceLookup.close(); } }
private void changeBaseScriptTypeFromPackageOrImport(final SourceUnit source, final AnnotatedNode parent, final AnnotationNode node) { Expression value = node.getMember("value"); if (!(value instanceof ClassExpression)) { addError("Annotation " + MY_TYPE_NAME + " member 'value' should be a class literal.", value); return; } List<ClassNode> classes = source.getAST().getClasses(); for (ClassNode classNode : classes) { if (classNode.isScriptBody()) { changeBaseScriptType(parent, classNode, value.getType()); } } }
public void testIsImplicitThisOnObject() { ModuleNode root = getAST("string.substring(2)", Phases.SEMANTIC_ANALYSIS); methodCallVisitor.visitClass(root.getClasses().get(0)); assertTrue(visited); assertFalse(isImplicitThis); }
public void testIsImplicitThisExplicitThis() { ModuleNode root = getAST("this.println()", Phases.SEMANTIC_ANALYSIS); methodCallVisitor.visitClass(root.getClasses().get(0)); assertTrue(visited); assertFalse(isImplicitThis); }
public void testIsImplicitThisNoObject() { ModuleNode root = getAST("println()", Phases.SEMANTIC_ANALYSIS); methodCallVisitor.visitClass(root.getClasses().get(0)); assertTrue(visited); assertTrue(isImplicitThis); } }
protected Class createClass(byte[] code, ClassNode classNode) { BytecodeProcessor bytecodePostprocessor = unit.getConfiguration().getBytecodePostprocessor(); byte[] fcode = code; if (bytecodePostprocessor!=null) { fcode = bytecodePostprocessor.processBytecode(classNode.getName(), fcode); } GroovyClassLoader cl = getDefiningClassLoader(); Class theClass = cl.defineClass(classNode.getName(), fcode, 0, fcode.length, unit.getAST().getCodeSource()); this.loadedClasses.add(theClass); if (generatedClass == null) { ModuleNode mn = classNode.getModule(); SourceUnit msu = null; if (mn != null) msu = mn.getContext(); ClassNode main = null; if (mn != null) main = (ClassNode) mn.getClasses().get(0); if (msu == su && main == classNode) generatedClass = theClass; } return theClass; }
private void changeBaseScriptTypeFromPackageOrImport(final SourceUnit source, final AnnotatedNode parent, final AnnotationNode node) { Expression value = node.getMember("value"); ClassNode scriptType; if (value == null) { scriptType = BASE_SCRIPT_TYPE; } else { if (!(value instanceof ClassExpression)) { addError("Annotation " + MY_TYPE_NAME + " member 'value' should be a class literal.", value); return; } scriptType = value.getType(); } List<ClassNode> classes = source.getAST().getClasses(); for (ClassNode classNode : classes) { if (classNode.isScriptBody()) { changeBaseScriptType(source, parent, classNode, scriptType, node); } } }
public void testStatementClass_FAILS() throws Exception { if (notYetImplemented()) return; ModuleNode module = parse("x = [1, 2, 3]; println(x)", "Cheese.groovy"); assertTrue("Should have statements", !module.getStatementBlock().isEmpty()); List classes = module.getClasses(); assertEquals("Number of classes", 1, classes.size()); ClassNode classNode = (ClassNode) classes.get(0); assertEquals("Class name", "Cheese", classNode.getName()); } }
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()); } }