public void visit(ASTNode[] nodes, SourceUnit source) {
List<ClassNode> classes = source.getAST().getClasses();
AnnotationNode annotation = null;
for (ClassNode clazz : classes) {
annotation = findAnnotation(clazz);
if (annotation != null) {
break;
}
}
if (annotation == null) {
return;
}
int[] array = extractLineNumberArray(annotation);
if (array != null) {
LineNumberVisitor visitor = new LineNumberVisitor(array);
for (ClassNode clazz : classes) {
visitor.visitClass(clazz);
}
}
String sourceName = extractSourceName(annotation);
if (sourceName != null) {
source.getAST().setDescription(sourceName);
// source.name = sourceName
Field field = ReflectionUtils.findField(SourceUnit.class, "name");
field.setAccessible(true);
ReflectionUtils.setField(field, source, sourceName);
}
}
@Override
public void call(SourceUnit source, GeneratorContext context, ClassNode classNode)
throws CompilationFailedException {
ImportCustomizer importCustomizer = new ImportCustomizer();
// Additional auto configuration
for (CompilerAutoConfiguration autoConfiguration :
GroovyCompiler.this.compilerAutoConfigurations) {
if (autoConfiguration.matches(classNode)) {
if (GroovyCompiler.this.configuration.isGuessImports()) {
autoConfiguration.applyImports(importCustomizer);
importCustomizer.call(source, context, classNode);
}
if (source.getAST().getClasses().size() > 0
&& classNode.equals(source.getAST().getClasses().get(0))) {
autoConfiguration.applyToMainClass(
GroovyCompiler.this.loader,
GroovyCompiler.this.configuration,
context,
source,
classNode);
}
autoConfiguration.apply(
GroovyCompiler.this.loader,
GroovyCompiler.this.configuration,
context,
source,
classNode);
}
}
importCustomizer.call(source, context, classNode);
}
public static void visitScriptCode(SourceUnit source, GroovyCodeVisitor transformer) {
source.getAST().getStatementBlock().visit(transformer);
for (Object method : source.getAST().getMethods()) {
MethodNode methodNode = (MethodNode) method;
methodNode.getCode().visit(transformer);
}
}
public static ClassNode getScriptClass(SourceUnit source) {
if (source.getAST().getStatementBlock().getStatements().isEmpty()
&& source.getAST().getMethods().isEmpty()) {
// There is no script class when there are no statements or methods declared in the script
return null;
}
return source.getAST().getClasses().get(0);
}
@Override
public void call(SourceUnit source) {
if (!source.getAST().getMethods().isEmpty()) {
hasMethods = true;
}
emptyScript = isEmpty(source);
}
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 boolean isEmpty(SourceUnit source) {
List<Statement> statements = source.getAST().getStatementBlock().getStatements();
for (Statement statement : statements) {
if (AstUtils.mayHaveAnEffect(statement)) {
return false;
}
}
// No statements, or no statements that have an effect
return true;
}
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 static void filterAndTransformStatements(
SourceUnit source, FilteredTransformer<? extends Statement, ? super Statement> transformer) {
ListIterator<Statement> statementIterator =
source.getAST().getStatementBlock().getStatements().listIterator();
while (statementIterator.hasNext()) {
Statement statement = statementIterator.next();
if (transformer.getSpec().isSatisfiedBy(statement)) {
Statement transformed = transformer.getTransformer().transform(statement);
statementIterator.set(transformed);
} else {
statementIterator.remove();
}
}
}
private Class doParseClass(GroovyCodeSource codeSource) {
validate(codeSource);
Class answer; // Was neither already loaded nor compiling, so compile and add to cache.
CompilationUnit unit = createCompilationUnit(config, codeSource.getCodeSource());
if (recompile != null && recompile || recompile == null && config.getRecompileGroovySource()) {
unit.addFirstPhaseOperation(
TimestampAdder.INSTANCE, CompilePhase.CLASS_GENERATION.getPhaseNumber());
}
SourceUnit su = null;
File file = codeSource.getFile();
if (file != null) {
su = unit.addSource(file);
} else {
URL url = codeSource.getURL();
if (url != null) {
su = unit.addSource(url);
} else {
su = unit.addSource(codeSource.getName(), codeSource.getScriptText());
}
}
ClassCollector collector = createCollector(unit, su);
unit.setClassgenCallback(collector);
int goalPhase = Phases.CLASS_GENERATION;
if (config != null && config.getTargetDirectory() != null) goalPhase = Phases.OUTPUT;
unit.compile(goalPhase);
answer = collector.generatedClass;
String mainClass = su.getAST().getMainClassName();
for (Object o : collector.getLoadedClasses()) {
Class clazz = (Class) o;
String clazzName = clazz.getName();
definePackage(clazzName);
setClassCacheEntry(clazz);
if (clazzName.equals(mainClass)) answer = clazz;
}
return answer;
}
@Override
public void call(SourceUnit source) throws CompilationFailedException {
hasPackageStatement = source.getAST().getPackageName() != null;
}
public void visit(ASTNode[] nodes, SourceUnit source) {
sourceUnit = source;
loader = null;
initContextClassLoader = false;
ModuleNode mn = (ModuleNode) nodes[0];
allowShortGrab = true;
allowShortGrabExcludes = true;
allowShortGrabConfig = true;
allowShortGrapes = true;
allowShortGrabResolver = true;
grabAliases = new HashSet<String>();
grabExcludeAliases = new HashSet<String>();
grabConfigAliases = new HashSet<String>();
grapesAliases = new HashSet<String>();
grabResolverAliases = new HashSet<String>();
for (ImportNode im : mn.getImports()) {
String alias = im.getAlias();
String className = im.getClassName();
if ((className.endsWith(GRAB_DOT_NAME) && ((alias == null) || (alias.length() == 0)))
|| (GRAB_CLASS_NAME.equals(alias))) {
allowShortGrab = false;
} else if (GRAB_CLASS_NAME.equals(className)) {
grabAliases.add(im.getAlias());
}
if ((className.endsWith(GRAPES_DOT_NAME) && ((alias == null) || (alias.length() == 0)))
|| (GRAPES_CLASS_NAME.equals(alias))) {
allowShortGrapes = false;
} else if (GRAPES_CLASS_NAME.equals(className)) {
grapesAliases.add(im.getAlias());
}
if ((className.endsWith(GRABRESOLVER_DOT_NAME) && ((alias == null) || (alias.length() == 0)))
|| (GRABRESOLVER_CLASS_NAME.equals(alias))) {
allowShortGrabResolver = false;
} else if (GRABRESOLVER_CLASS_NAME.equals(className)) {
grabResolverAliases.add(im.getAlias());
}
}
List<Map<String, Object>> grabMaps = new ArrayList<Map<String, Object>>();
List<Map<String, Object>> grabExcludeMaps = new ArrayList<Map<String, Object>>();
for (ClassNode classNode : sourceUnit.getAST().getClasses()) {
grabAnnotations = new ArrayList<AnnotationNode>();
grabExcludeAnnotations = new ArrayList<AnnotationNode>();
grabConfigAnnotations = new ArrayList<AnnotationNode>();
grapesAnnotations = new ArrayList<AnnotationNode>();
grabResolverAnnotations = new ArrayList<AnnotationNode>();
visitClass(classNode);
ClassNode grapeClassNode = ClassHelper.make(Grape.class);
List<Statement> grabResolverInitializers = new ArrayList<Statement>();
if (!grapesAnnotations.isEmpty()) {
for (AnnotationNode node : grapesAnnotations) {
Expression init = node.getMember("initClass");
Expression value = node.getMember("value");
if (value instanceof ListExpression) {
for (Object o : ((ListExpression) value).getExpressions()) {
if (o instanceof ConstantExpression) {
extractGrab(init, (ConstantExpression) o);
}
}
} else if (value instanceof ConstantExpression) {
extractGrab(init, (ConstantExpression) value);
}
// don't worry if it's not a ListExpression, or AnnotationConstant, etc.
// the rest of GroovyC will flag it as a syntax error later, so we don't
// need to raise the error ourselves
}
}
if (!grabResolverAnnotations.isEmpty()) {
grabResolverAnnotationLoop:
for (AnnotationNode node : grabResolverAnnotations) {
Map<String, Object> grabResolverMap = new HashMap<String, Object>();
Expression value = node.getMember("value");
ConstantExpression ce = null;
if (value != null && value instanceof ConstantExpression) {
ce = (ConstantExpression) value;
}
String sval = null;
if (ce != null && ce.getValue() instanceof String) {
sval = (String) ce.getValue();
}
if (sval != null && sval.length() > 0) {
for (String s : GRABRESOLVER_REQUIRED) {
Expression member = node.getMember(s);
if (member != null) {
addError(
"The attribute \""
+ s
+ "\" conflicts with attribute 'value' in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabResolverAnnotationLoop;
}
}
grabResolverMap.put("name", sval);
grabResolverMap.put("root", sval);
} else {
for (String s : GRABRESOLVER_REQUIRED) {
Expression member = node.getMember(s);
if (member == null) {
addError(
"The missing attribute \""
+ s
+ "\" is required in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabResolverAnnotationLoop;
} else if (member != null && !(member instanceof ConstantExpression)) {
addError(
"Attribute \""
+ s
+ "\" has value "
+ member.getText()
+ " but should be an inline constant in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabResolverAnnotationLoop;
}
grabResolverMap.put(s, ((ConstantExpression) member).getValue());
}
}
Grape.addResolver(grabResolverMap);
addGrabResolverAsStaticInitIfNeeded(
grapeClassNode, node, grabResolverInitializers, grabResolverMap);
}
}
if (!grabConfigAnnotations.isEmpty()) {
for (AnnotationNode node : grabConfigAnnotations) {
checkForClassLoader(node);
checkForInitContextClassLoader(node);
checkForAutoDownload(node);
checkForDisableChecksums(node);
}
addInitContextClassLoaderIfNeeded(classNode);
}
if (!grabExcludeAnnotations.isEmpty()) {
grabExcludeAnnotationLoop:
for (AnnotationNode node : grabExcludeAnnotations) {
Map<String, Object> grabExcludeMap = new HashMap<String, Object>();
checkForConvenienceForm(node, true);
for (String s : GRABEXCLUDE_REQUIRED) {
Expression member = node.getMember(s);
if (member == null) {
addError(
"The missing attribute \""
+ s
+ "\" is required in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabExcludeAnnotationLoop;
} else if (member != null && !(member instanceof ConstantExpression)) {
addError(
"Attribute \""
+ s
+ "\" has value "
+ member.getText()
+ " but should be an inline constant in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabExcludeAnnotationLoop;
}
grabExcludeMap.put(s, ((ConstantExpression) member).getValue());
}
grabExcludeMaps.add(grabExcludeMap);
}
}
if (!grabAnnotations.isEmpty()) {
grabAnnotationLoop:
for (AnnotationNode node : grabAnnotations) {
Map<String, Object> grabMap = new HashMap<String, Object>();
checkForConvenienceForm(node, false);
for (String s : GRAB_ALL) {
Expression member = node.getMember(s);
if (member == null && !GRAB_OPTIONAL.contains(s)) {
addError(
"The missing attribute \""
+ s
+ "\" is required in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabAnnotationLoop;
} else if (member != null && !(member instanceof ConstantExpression)) {
addError(
"Attribute \""
+ s
+ "\" has value "
+ member.getText()
+ " but should be an inline constant in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabAnnotationLoop;
}
if (node.getMember(s) != null) grabMap.put(s, ((ConstantExpression) member).getValue());
}
grabMaps.add(grabMap);
callGrabAsStaticInitIfNeeded(classNode, grapeClassNode, node, grabExcludeMaps);
}
}
if (!grabResolverInitializers.isEmpty()) {
classNode.addStaticInitializerStatements(grabResolverInitializers, true);
}
}
if (!grabMaps.isEmpty()) {
Map<String, Object> basicArgs = new HashMap<String, Object>();
basicArgs.put("classLoader", loader != null ? loader : sourceUnit.getClassLoader());
if (!grabExcludeMaps.isEmpty()) basicArgs.put("excludes", grabExcludeMaps);
if (autoDownload != null) basicArgs.put(AUTO_DOWNLOAD_SETTING, autoDownload);
if (disableChecksums != null) basicArgs.put(DISABLE_CHECKSUMS_SETTING, disableChecksums);
try {
Grape.grab(basicArgs, grabMaps.toArray(new Map[grabMaps.size()]));
// grab may have added more transformations through new URLs added to classpath, so do one
// more scan
if (compilationUnit != null) {
ASTTransformationVisitor.addGlobalTransformsAfterGrab(
compilationUnit.getASTTransformationsContext());
}
} catch (RuntimeException re) {
// Decided against syntax exception since this is not a syntax error.
// The down side is we lose line number information for the offending
// @Grab annotation.
source.addException(re);
}
}
}
public void visit(ASTNode[] nodes, SourceUnit source) {
sourceUnit = source;
loader = null;
initContextClassLoader = false;
ModuleNode mn = (ModuleNode) nodes[0];
allowShortGrab = true;
allowShortGrabExcludes = true;
allowShortGrabConfig = true;
allowShortGrapes = true;
allowShortGrabResolver = true;
grabAliases = new HashSet<String>();
grabExcludeAliases = new HashSet<String>();
grabConfigAliases = new HashSet<String>();
grapesAliases = new HashSet<String>();
grabResolverAliases = new HashSet<String>();
for (ImportNode im : mn.getImports()) {
String alias = im.getAlias();
String className = im.getClassName();
if ((className.endsWith(GRAB_DOT_NAME) && ((alias == null) || (alias.length() == 0)))
|| (GRAB_CLASS_NAME.equals(alias))) {
allowShortGrab = false;
} else if (GRAB_CLASS_NAME.equals(className)) {
grabAliases.add(im.getAlias());
}
if ((className.endsWith(GRAPES_DOT_NAME) && ((alias == null) || (alias.length() == 0)))
|| (GRAPES_CLASS_NAME.equals(alias))) {
allowShortGrapes = false;
} else if (GRAPES_CLASS_NAME.equals(className)) {
grapesAliases.add(im.getAlias());
}
if ((className.endsWith(GRABRESOLVER_DOT_NAME) && ((alias == null) || (alias.length() == 0)))
|| (GRABRESOLVER_CLASS_NAME.equals(alias))) {
allowShortGrabResolver = false;
} else if (GRABRESOLVER_CLASS_NAME.equals(className)) {
grabResolverAliases.add(im.getAlias());
}
}
List<Map<String, Object>> grabMaps = new ArrayList<Map<String, Object>>();
List<Map<String, Object>> grabMapsInit = new ArrayList<Map<String, Object>>();
List<Map<String, Object>> grabExcludeMaps = new ArrayList<Map<String, Object>>();
for (ClassNode classNode : sourceUnit.getAST().getClasses()) {
grabAnnotations = new ArrayList<AnnotationNode>();
grabExcludeAnnotations = new ArrayList<AnnotationNode>();
grabConfigAnnotations = new ArrayList<AnnotationNode>();
grapesAnnotations = new ArrayList<AnnotationNode>();
grabResolverAnnotations = new ArrayList<AnnotationNode>();
visitClass(classNode);
ClassNode grapeClassNode = ClassHelper.make(Grape.class);
List<Statement> grabResolverInitializers = new ArrayList<Statement>();
if (!grapesAnnotations.isEmpty()) {
for (AnnotationNode node : grapesAnnotations) {
Expression init = node.getMember("initClass");
Expression value = node.getMember("value");
if (value instanceof ListExpression) {
for (Object o : ((ListExpression) value).getExpressions()) {
if (o instanceof ConstantExpression) {
extractGrab(init, (ConstantExpression) o);
}
}
} else if (value instanceof ConstantExpression) {
extractGrab(init, (ConstantExpression) value);
}
// don't worry if it's not a ListExpression, or AnnotationConstant, etc.
// the rest of GroovyC will flag it as a syntax error later, so we don't
// need to raise the error ourselves
}
}
if (!grabResolverAnnotations.isEmpty()) {
grabResolverAnnotationLoop:
for (AnnotationNode node : grabResolverAnnotations) {
Map<String, Object> grabResolverMap = new HashMap<String, Object>();
String sval = getMemberStringValue(node, "value");
if (sval != null && sval.length() > 0) {
for (String s : GRABRESOLVER_REQUIRED) {
String mval = getMemberStringValue(node, s);
if (mval != null && mval.isEmpty()) mval = null;
if (mval != null) {
addError(
"The attribute \""
+ s
+ "\" conflicts with attribute 'value' in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabResolverAnnotationLoop;
}
}
grabResolverMap.put("name", sval);
grabResolverMap.put("root", sval);
} else {
for (String s : GRABRESOLVER_REQUIRED) {
String mval = getMemberStringValue(node, s);
if (mval != null && mval.isEmpty()) mval = null;
Expression member = node.getMember(s);
if (member == null || mval == null) {
addError(
"The missing attribute \""
+ s
+ "\" is required in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabResolverAnnotationLoop;
} else if (mval == null) {
addError(
"Attribute \""
+ s
+ "\" has value "
+ member.getText()
+ " but should be an inline constant String in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabResolverAnnotationLoop;
}
grabResolverMap.put(s, mval);
}
}
// If no scheme is specified for the repository root,
// then turn it into a URI relative to that of the source file.
String root = (String) grabResolverMap.get("root");
if (root != null && !root.contains(":")) {
URI sourceURI = null;
// Since we use the data: scheme for StringReaderSources (which are fairly common)
// and those are not hierarchical we can't use them for making an absolute URI.
if (!(getSourceUnit().getSource() instanceof StringReaderSource)) {
// Otherwise let's trust the source to know where it is from.
// And actually InputStreamReaderSource doesn't know what to do and so returns null.
sourceURI = getSourceUnit().getSource().getURI();
}
// If source doesn't know how to get a reference to itself,
// then let's use the current working directory, since the repo can be relative to that.
if (sourceURI == null) {
sourceURI = new File(".").toURI();
}
try {
URI rootURI = sourceURI.resolve(new URI(root));
grabResolverMap.put("root", rootURI.toString());
} catch (URISyntaxException e) {
// We'll be silent here.
// If the URI scheme is unknown or not hierarchical, then we just can't help them and
// shouldn't cause any trouble either.
// addError("Attribute \"root\" has value '" + root + "' which can't be turned into a
// valid URI relative to it's source '" + getSourceUnit().getName() + "' @" +
// node.getClassNode().getNameWithoutPackage() + " annotations", node);
}
}
Grape.addResolver(grabResolverMap);
addGrabResolverAsStaticInitIfNeeded(
grapeClassNode, node, grabResolverInitializers, grabResolverMap);
}
}
if (!grabConfigAnnotations.isEmpty()) {
for (AnnotationNode node : grabConfigAnnotations) {
checkForClassLoader(node);
checkForInitContextClassLoader(node);
checkForAutoDownload(node);
checkForDisableChecksums(node);
}
addInitContextClassLoaderIfNeeded(classNode);
}
if (!grabExcludeAnnotations.isEmpty()) {
grabExcludeAnnotationLoop:
for (AnnotationNode node : grabExcludeAnnotations) {
Map<String, Object> grabExcludeMap = new HashMap<String, Object>();
checkForConvenienceForm(node, true);
for (String s : GRABEXCLUDE_REQUIRED) {
Expression member = node.getMember(s);
if (member == null) {
addError(
"The missing attribute \""
+ s
+ "\" is required in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabExcludeAnnotationLoop;
} else if (member != null && !(member instanceof ConstantExpression)) {
addError(
"Attribute \""
+ s
+ "\" has value "
+ member.getText()
+ " but should be an inline constant in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabExcludeAnnotationLoop;
}
grabExcludeMap.put(s, ((ConstantExpression) member).getValue());
}
grabExcludeMaps.add(grabExcludeMap);
}
}
if (!grabAnnotations.isEmpty()) {
grabAnnotationLoop:
for (AnnotationNode node : grabAnnotations) {
Map<String, Object> grabMap = new HashMap<String, Object>();
checkForConvenienceForm(node, false);
for (String s : GRAB_ALL) {
Expression member = node.getMember(s);
String mval = getMemberStringValue(node, s);
if (mval != null && mval.isEmpty()) member = null;
if (member == null && !GRAB_OPTIONAL.contains(s)) {
addError(
"The missing attribute \""
+ s
+ "\" is required in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabAnnotationLoop;
} else if (member != null && !(member instanceof ConstantExpression)) {
addError(
"Attribute \""
+ s
+ "\" has value "
+ member.getText()
+ " but should be an inline constant in @"
+ node.getClassNode().getNameWithoutPackage()
+ " annotations",
node);
continue grabAnnotationLoop;
}
if (node.getMember(s) != null) {
grabMap.put(s, ((ConstantExpression) member).getValue());
}
}
grabMaps.add(grabMap);
if ((node.getMember("initClass") == null)
|| (node.getMember("initClass") == ConstantExpression.TRUE)) {
grabMapsInit.add(grabMap);
}
}
callGrabAsStaticInitIfNeeded(classNode, grapeClassNode, grabMapsInit, grabExcludeMaps);
}
if (!grabResolverInitializers.isEmpty()) {
classNode.addStaticInitializerStatements(grabResolverInitializers, true);
}
}
if (!grabMaps.isEmpty()) {
Map<String, Object> basicArgs = new HashMap<String, Object>();
basicArgs.put("classLoader", loader != null ? loader : sourceUnit.getClassLoader());
if (!grabExcludeMaps.isEmpty()) basicArgs.put("excludes", grabExcludeMaps);
if (autoDownload != null) basicArgs.put(AUTO_DOWNLOAD_SETTING, autoDownload);
if (disableChecksums != null) basicArgs.put(DISABLE_CHECKSUMS_SETTING, disableChecksums);
try {
Grape.grab(basicArgs, grabMaps.toArray(new Map[grabMaps.size()]));
// grab may have added more transformations through new URLs added to classpath, so do one
// more scan
if (compilationUnit != null) {
ASTTransformationVisitor.addGlobalTransformsAfterGrab(
compilationUnit.getASTTransformationsContext());
}
} catch (RuntimeException re) {
// Decided against syntax exception since this is not a syntax error.
// The down side is we lose line number information for the offending
// @Grab annotation.
source.addException(re);
}
}
}
public void visit(ASTNode[] nodes, SourceUnit source) {
for (ClassNode node : source.getAST().getClasses()) {
performInjectionOnArtefactType(source, node, artefactType);
}
}
