@Override public void call(SourceUnit source) throws CompilationFailedException { module = source.getAST(); throw new AstSuccessfullyCaptured(); } }, compilePhase.getPhaseNumber());
public void call(SourceUnit source) throws CompilationFailedException { instance.visit(new ASTNode[] {source.getAST()}, source); } };
@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 ); }
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) {
public void call(SourceUnit source) throws CompilationFailedException { source.convert(); CompilationUnit.this.ast.addModule(source.getAST()); if (CompilationUnit.this.progressCallback != null) { CompilationUnit.this.progressCallback.call(source, CompilationUnit.this.phase); } } };
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); } } }
final List<ClassNode> innerClassNodes = source.getAST().getClasses(); nameToInnerClassesNodesMap = new HashMap<>(innerClassNodes.size()); for (ClassNode type : innerClassNodes) { final ClassNode importedType = source.getAST().getImportType(methodName); if (importedType != null) { return importedType;
@Override public void call(final SourceUnit source, final GeneratorContext context, final ClassNode classNode) throws CompilationFailedException { final ModuleNode ast = source.getAST(); for (Import anImport : imports) { switch (anImport.type) { case regular: ast.addImport(anImport.alias, anImport.classNode); break; case staticImport: ast.addStaticImport(anImport.classNode, anImport.field, anImport.alias); break; case staticStar: ast.addStaticStarImport(anImport.alias, anImport.classNode); break; case star: ast.addStarImport(anImport.star); break; } } }
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 ModuleNode parse(String text, String description) throws Exception { SourceUnit unit = SourceUnit.create(description, text); unit.parse(); unit.convert(); return unit.getAST(); } }
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); } } }
cu.addSource(su); cu.compile(Phases.CONVERSION); su.getAST().addClass(cn); cu.compile(Phases.CLASS_GENERATION); @SuppressWarnings("unchecked")
public ModuleNode getAST(String source, int untilPhase) { SourceUnit unit = SourceUnit.create("Test", source); CompilationUnit compUnit = new CompilationUnit(); compUnit.addSource(unit); compUnit.compile(untilPhase); return unit.getAST(); }
public void call(SourceUnit source, GeneratorContext context, ClassNode classNode) { for (Object statement : source.getAST().getStatementBlock().getStatements()) ((ExpressionStatement) statement).visit(new CustomCodeVisitorSupport()); } }
unit.convert(); BlockStatement blockStat = unit.getAST().getStatementBlock(); Assert.that(blockStat != null && blockStat.getStatements().size() == 1); Statement stat = blockStat.getStatements().get(0);
@Override public void call(final SourceUnit source, final GeneratorContext context, final ClassNode classNode) throws CompilationFailedException { final ModuleNode ast = source.getAST(); if (!isPackageAllowed && ast.getPackage() != null) { throw new SecurityException("Package definitions are not allowed");
String mainClass = su.getAST().getMainClassName(); for (Object o : collector.getLoadedClasses()) { Class clazz = (Class) o;
final ModuleNode tree = source.getAST(); if (applyToAllClasses) {