Refine search
if (!type.hasPackageName() && module.hasPackageName() && !(type instanceof ConstructedClassWithPackage)) { type.setName(module.getPackageName() + name); newNameUsed = true; List<ClassNode> moduleClasses = module.getClasses(); for (ClassNode mClass : moduleClasses) { if (mClass.getName().equals(type.getName())) { if (resolveAliasFromModule(type)) return true; if (module.hasPackageName()) { ConstructedClassWithPackage tmp = new ConstructedClassWithPackage(module.getPackageName(), name); if (resolve(tmp, false, false, false)) { ambiguousClass(type, tmp, name); for (ImportNode importNode : module.getStaticImports().values()) { if (importNode.getFieldName().equals(name)) { ClassNode tmp = new ConstructedNestedClass(importNode.getType(), name); for (ImportNode importNode : module.getStarImports()) { String packagePrefix = importNode.getPackageName(); for (ImportNode importNode : module.getStaticStarImports().values()) { ClassNode tmp = new ConstructedNestedClass(importNode.getType(), name); if (resolve(tmp, false, false, true)) {
resolveGenericsHeader(node.getGenericsTypes()); ModuleNode module = node.getModule(); if (!module.hasImportsResolved()) { for (ImportNode importNode : module.getImports()) { currImportNode = importNode; ClassNode type = importNode.getType(); addError("unable to resolve class " + type.getName(), type); for (ImportNode importNode : module.getStaticStarImports().values()) { ClassNode type = importNode.getType(); if (resolve(type, false, false, true)) continue; addError("unable to resolve class " + type.getName(), type); for (ImportNode importNode : module.getStaticImports().values()) { ClassNode type = importNode.getType(); if (resolve(type, true, true, true)) continue; addError("unable to resolve class " + type.getName(), type); for (ImportNode importNode : module.getStaticStarImports().values()) { ClassNode type = importNode.getType(); if (resolve(type, true, true, true)) continue; addError("unable to resolve class " + type.getName(), type); module.setImportsResolved(true);
if (sourceUnit.getAST() != null) { sourceUnit.getAST().visit(transformer); if (sourceUnit.getAST().getStatementBlock() != null) { sourceUnit.getAST().getStatementBlock().visit(transformer); if (sourceUnit.getAST().getClasses() != null) { for (ClassNode classNode : sourceUnit.getAST().getClasses()) { if (classNode.getMethods() != null) { for (MethodNode node : classNode.getMethods()) { if (node != null && node.getCode() != null) { node.getCode().visit(transformer); if (classNode.getDeclaredConstructors() != null) { for (MethodNode node : classNode.getDeclaredConstructors()) { if (node != null && node.getCode() != null) { if (sourceUnit.getAST().getMethods() != null) { for (MethodNode node : sourceUnit.getAST().getMethods()) { if (node != null) { if (node.getParameters() != null) {
@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; } } }
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()); }
@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 visit(ASTNode[] nodes, final SourceUnit sourceUnit) { ModuleNode mn = sourceUnit.getAST(); try{ if(mn!=null){ ClassNode scriptClassNode = mn.getScriptClassDummy(); LoadFieldVisitor loadFieldVisitor = new LoadFieldVisitor(sourceUnit); loadFieldVisitor.visitClass(scriptClassNode); if(mn.getStatementBlock().isEmpty()){ mn.getStatementBlock().addStatement(new ExpressionStatement( new DeclarationExpression( new VariableExpression("___groovy__run__stub___"), mn.getStatementBlock().visit(new CodeVisitorSupport() { public void visitExpressionStatement(ExpressionStatement statement){ Expression expression = statement.getExpression(); scriptClassNode.addInterface(new ClassNode(ScriptBody.class)); staticFieldVisitor.visitClass(scriptClassNode); List<MethodNode> methods = mn.getMethods(); if(methods!=null){ for(MethodNode method: methods){ List<ClassNode> cnodes = mn.getClasses(); iterateClassNodes: for(final ClassNode cn: cnodes){
ModuleNode module = currentClass.getModule(); if (module == null) return false; String name = type.getName(); pname = name.substring(0, index); ClassNode aliasedNode = null; ImportNode importNode = module.getImport(pname); if (importNode != null && importNode != currImportNode) { aliasedNode = importNode.getType(); importNode = module.getStaticImports().get(pname); if (importNode != null && importNode != currImportNode) { if ((tmp.getModifiers() & Opcodes.ACC_STATIC) != 0) { type.setRedirect(tmp.redirect()); return true;
sourceUnit.getAST().getImports(), sourceUnit.getAST().getStarImports(), sourceUnit.getSource(), sourceUnit ); if (sourceUnit.getAST() != null) { sourceUnit.getAST().visit(transformer); if (sourceUnit.getAST().getStatementBlock() != null) { sourceUnit.getAST().getStatementBlock().visit(transformer); if (sourceUnit.getAST().getClasses() != null) { for (ClassNode classNode : sourceUnit.getAST().getClasses()) { if (classNode.getMethods() != null) { for (MethodNode node : classNode.getMethods()) { if (node != null && node.getCode() != null) { node.getCode().visit(transformer); if (classNode.getDeclaredConstructors() != null) { for (MethodNode node : classNode.getDeclaredConstructors()) { if (node != null && node.getCode() != null) { if (sourceUnit.getAST().getMethods() != null) { for (MethodNode node : sourceUnit.getAST().getMethods()) { if (node != null) { if (node.getParameters() != null) {
ModuleNode module = currentClass.getModule(); if (module == null) return false; String name = type.getName(); ClassNode aliasedNode = module.getImport(pname); type.setRedirect(aliasedNode); return true; } else {
node = node.redirect(); String name = node.getName(); ClassNode stored = classes.get(name); if (stored != null && stored != node) { SourceUnit nodeSource = node.getModule().getContext(); SourceUnit storedSource = stored.getModule().getContext(); String txt = "Invalid duplicate class definition of class " + node.getName() + " : "; if (nodeSource == storedSource) { txt += "The source " + nodeSource.getName() + " contains at least two definitions of the class " + node.getName() + ".\n"; if (node.isScriptBody() || stored.isScriptBody()) { txt += "One of the classes is an explicit generated class using the class statement, the other is a class generated from" + txt += "The sources " + nodeSource.getName() + " and " + storedSource.getName() + " each contain a class with the name " + node.getName() + ".\n"; nodeSource.getErrorCollector().addErrorAndContinue(
@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"); for (ImportNode importNode : ast.getImports()) { final String className = importNode.getClassName(); assertImportIsAllowed(className); for (ImportNode importNode : ast.getStarImports()) { final String className = importNode.getPackageName(); assertStarImportIsAllowed(className + "*"); for (Map.Entry<String, ImportNode> entry : ast.getStaticImports().entrySet()) { final String className = entry.getValue().getClassName(); assertStaticImportIsAllowed(entry.getKey(), className); for (Map.Entry<String, ImportNode> entry : ast.getStaticStarImports().entrySet()) { final String className = entry.getValue().getClassName(); assertStaticImportIsAllowed(entry.getKey(), className); ast.getStatementBlock().visit(visitor); for (ClassNode clNode : ast.getClasses()) { if (clNode!=classNode) { checkMethodDefinitionAllowed(clNode); for (MethodNode methodNode : clNode.getMethods()) { if (!methodNode.isSynthetic() && methodNode.getCode() != null) { methodNode.getCode().visit(visitor);
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); } } }
AnnotatedNode annotatedNode = (AnnotatedNode) nodes[1]; if (!type().equals(node.getClassNode())) { internalError("Transformation called from wrong annotation: " + node.getClassNode().getName()); final ModuleNode tree = source.getAST(); if (applyToAllClasses) { final List<ClassNode> classes = tree.getClasses(); for (ClassNode classNode : classes) { visitClass(classNode); final List<ClassNode> classes = tree.getClasses(); for (ClassNode classNode : classes) { if (classNode.isScript()) { visitClass(classNode);
/** * 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; }
Iterator<ImportNode> iter = source.getAST().getImports().iterator(); while (iter.hasNext()) { ImportNode importedClass = iter.next(); Field field = ModuleNode.class.getDeclaredField("imports"); field.setAccessible(true); Map value = (Map) field.get(source.getAST()); value.remove(importedClass.getAlias()); } catch (Exception e) { iter = source.getAST().getStaticImports().values().iterator(); while (iter.hasNext()) { ImportNode importedClass = iter.next(); iter = source.getAST().getStaticStarImports().values().iterator(); while (iter.hasNext()) { ImportNode importedClass = iter.next(); Iterator<ClassNode> classes = source.getAST().getClasses().iterator(); while (classes.hasNext()) { ClassNode classNode = classes.next(); for (MethodNode methodNode : new ArrayList<MethodNode>(scriptClass.getMethods())) { if (!methodNode.getName().equals("run")) { AstUtils.removeMethod(scriptClass, methodNode); source.getAST().getMethods().clear();
grapesAliases = new HashSet<String>(); grabResolverAliases = new HashSet<String>(); for (ImportNode im : mn.getImports()) { String alias = im.getAlias(); String className = im.getClassName(); List<Map<String,Object>> grabExcludeMaps = new ArrayList<Map<String,Object>>(); for (ClassNode classNode : sourceUnit.getAST().getClasses()) { grabAnnotations = new ArrayList<AnnotationNode>(); grabExcludeAnnotations = new ArrayList<AnnotationNode>(); 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; Expression member = node.getMember(s); if (member == null || (mval != null && mval.isEmpty())) { 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; if (!(getSourceUnit().getSource() instanceof StringReaderSource)) { sourceURI = getSourceUnit().getSource().getURI();
public void visit(ASTNode[] nodes, final SourceUnit source) { log.log(Level.FINE, "Transforming source to add default import package"); for (Class<?> defaultImport : defaultImports) { log.log(Level.FINE, "Adding default import for class " + defaultImport.getName()); if (source.getAST().getImport(defaultImport.getSimpleName()) == null) { source.getAST().addImport(defaultImport.getSimpleName(), ClassHelper.make(defaultImport)); } } for (Class<?> defaultStaticImport : defaultStaticImports) { log.log(Level.FINE, "Adding default static import for class " + defaultStaticImport.getName()); if (!source.getAST().getStaticStarImports().containsKey(defaultStaticImport.getSimpleName())) { source.getAST().addStaticStarImport(defaultStaticImport.getSimpleName(), ClassHelper.make(defaultStaticImport)); } } } }
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 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; } } }