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 Expression transformMapEntryExpression( MapEntryExpression me, ClassNode constructorCallType) { Expression key = me.getKeyExpression(); Expression value = me.getValueExpression(); ModuleNode module = currentClass.getModule(); if (module != null && key instanceof ConstantExpression) { Map<String, ImportNode> importNodes = module.getStaticImports(); if (importNodes.containsKey(key.getText())) { ImportNode importNode = importNodes.get(key.getText()); if (importNode.getType().equals(constructorCallType)) { String newKey = importNode.getFieldName(); return new MapEntryExpression( new ConstantExpression(newKey), value.transformExpression(this)); } } } return me; }
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); } } }
private Expression findStaticMethodImportFromModule(Expression method, Expression args) { ModuleNode module = currentClass.getModule(); if (module == null || !(method instanceof ConstantExpression)) return null; Map<String, ImportNode> importNodes = module.getStaticImports(); ConstantExpression ce = (ConstantExpression) method; Expression expression; Object value = ce.getValue(); // skip non-Strings, e.g. Integer if (!(value instanceof String)) return null; final String name = (String) value; // look for one of these: // import static SomeClass.method [as otherName] // when resolving methodCall() or getProp() or setProp() if (importNodes.containsKey(name)) { ImportNode importNode = importNodes.get(name); expression = findStaticMethod(importNode.getType(), importNode.getFieldName(), args); if (expression != null) return expression; expression = findStaticPropertyAccessorGivenArgs( importNode.getType(), getPropNameForAccessor(importNode.getFieldName()), args); if (expression != null) { return new StaticMethodCallExpression( importNode.getType(), importNode.getFieldName(), args); } } // look for one of these: // import static SomeClass.someProp [as otherName] // when resolving getProp() or setProp() if (validPropName(name)) { String propName = getPropNameForAccessor(name); if (importNodes.containsKey(propName)) { ImportNode importNode = importNodes.get(propName); expression = findStaticMethod( importNode.getType(), prefix(name) + capitalize(importNode.getFieldName()), args); if (expression != null) return expression; expression = findStaticPropertyAccessorGivenArgs( importNode.getType(), importNode.getFieldName(), args); if (expression != null) { return new StaticMethodCallExpression( importNode.getType(), prefix(name) + capitalize(importNode.getFieldName()), args); } } } Map<String, ImportNode> starImports = module.getStaticStarImports(); ClassNode starImportType; if (currentClass.isEnum() && starImports.containsKey(currentClass.getName())) { ImportNode importNode = starImports.get(currentClass.getName()); starImportType = importNode == null ? null : importNode.getType(); expression = findStaticMethod(starImportType, name, args); if (expression != null) return expression; } else { for (ImportNode importNode : starImports.values()) { starImportType = importNode == null ? null : importNode.getType(); expression = findStaticMethod(starImportType, name, args); if (expression != null) return expression; expression = findStaticPropertyAccessorGivenArgs(starImportType, getPropNameForAccessor(name), args); if (expression != null) { return new StaticMethodCallExpression(starImportType, name, args); } } } return null; }
private Expression findStaticFieldOrPropAccessorImportFromModule(String name) { ModuleNode module = currentClass.getModule(); if (module == null) return null; Map<String, ImportNode> importNodes = module.getStaticImports(); Expression expression; String accessorName = getAccessorName(name); // look for one of these: // import static MyClass.setProp [as setOtherProp] // import static MyClass.getProp [as getOtherProp] // when resolving prop reference if (importNodes.containsKey(accessorName)) { ImportNode importNode = importNodes.get(accessorName); expression = findStaticPropertyAccessorByFullName(importNode.getType(), importNode.getFieldName()); if (expression != null) return expression; expression = findStaticPropertyAccessor( importNode.getType(), getPropNameForAccessor(importNode.getFieldName())); if (expression != null) return expression; } if (accessorName.startsWith("get")) { accessorName = "is" + accessorName.substring(3); if (importNodes.containsKey(accessorName)) { ImportNode importNode = importNodes.get(accessorName); expression = findStaticPropertyAccessorByFullName(importNode.getType(), importNode.getFieldName()); if (expression != null) return expression; expression = findStaticPropertyAccessor( importNode.getType(), getPropNameForAccessor(importNode.getFieldName())); if (expression != null) return expression; } } // look for one of these: // import static MyClass.prop [as otherProp] // when resolving prop or field reference if (importNodes.containsKey(name)) { ImportNode importNode = importNodes.get(name); expression = findStaticPropertyAccessor(importNode.getType(), importNode.getFieldName()); if (expression != null) return expression; expression = findStaticField(importNode.getType(), importNode.getFieldName()); if (expression != null) return expression; } // look for one of these: // import static MyClass.* // when resolving prop or field reference for (ImportNode importNode : module.getStaticStarImports().values()) { ClassNode node = importNode.getType(); expression = findStaticPropertyAccessor(node, name); if (expression != null) return expression; expression = findStaticField(node, name); if (expression != null) return expression; } return null; }
private Expression findStaticFieldOrPropAccessorImportFromModule(String name) { ModuleNode module = currentClass.getModule(); if (module == null) return null; Map<String, ImportNode> importNodes = module.getStaticImports(); Expression expression = null; String accessorName = getAccessorName(name); // look for one of these: // import static MyClass.setProp [as setOtherProp] // import static MyClass.getProp [as getOtherProp] // when resolving prop reference if (importNodes.containsKey(accessorName)) { ImportNode importNode = importNodes.get(accessorName); expression = findStaticPropertyAccessorByFullName(importNode.getType(), importNode.getFieldName()); if (expression != null) return expression; expression = findStaticPropertyAccessor( importNode.getType(), getPropNameForAccessor(importNode.getFieldName())); if (expression != null) return expression; } if (accessorName.startsWith("get")) { accessorName = "is" + accessorName.substring(3); if (importNodes.containsKey(accessorName)) { ImportNode importNode = importNodes.get(accessorName); expression = findStaticPropertyAccessorByFullName(importNode.getType(), importNode.getFieldName()); if (expression != null) return expression; expression = findStaticPropertyAccessor( importNode.getType(), getPropNameForAccessor(importNode.getFieldName())); if (expression != null) return expression; } } // look for one of these: // import static MyClass.prop [as otherProp] // when resolving prop or field reference if (importNodes.containsKey(name)) { ImportNode importNode = importNodes.get(name); // GRECLIPSE add try { if (!isReconcile) { // GRECLIPSE end expression = findStaticPropertyAccessor(importNode.getType(), importNode.getFieldName()); if (expression != null) return expression; // GRECLIPSE add } // end expression = findStaticField(importNode.getType(), importNode.getFieldName()); if (expression != null) return expression; // GRECLIPSE add } finally { // store the identifier to facilitate organizing static imports if (expression != null) expression.setNodeMetaData("static.import.alias", name); } // GRECLIPSE end } // look for one of these: // import static MyClass.* // when resolving prop or field reference for (ImportNode importNode : module.getStaticStarImports().values()) { ClassNode node = importNode.getType(); expression = findStaticPropertyAccessor(node, name); if (expression != null) return expression; expression = findStaticField(node, name); if (expression != null) return expression; } return null; }