import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public boolean visitVariableDefinitionEntry(VariableDefinitionEntry node) {
    Expression initializer = node.astInitializer();
    if (initializer instanceof VariableReference) {
        JavaParser.ResolvedNode resolved = mContext.resolve(initializer);
        //noinspection SuspiciousMethodCalls
        if (resolved != null && mVariables.contains(resolved)) {
            JavaParser.ResolvedNode resolvedVariable = mContext.resolve(node);
            if (resolvedVariable instanceof JavaParser.ResolvedVariable) {
                JavaParser.ResolvedVariable variable = (JavaParser.ResolvedVariable) resolvedVariable;
                mVariables.add(variable);
            }
        }
    }
    return super.visitVariableDefinitionEntry(node);
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
private VariableDefinitionEntry getPublicStaticFinalStringVar(Modifiers node) {
    if (!isPublicStaticFinalField(node) && !isInterface(node))
        return null;

    Node parent = node.getParent();
    if (!(parent instanceof VariableDefinition))
        return null;

    VariableDefinition field = (VariableDefinition) parent;
    if (!field.astTypeReference().getTypeName().equals("String"))
        return null;

    StrictListAccessor<VariableDefinitionEntry, VariableDefinition> vars = field.astVariables();
    if (vars.size() != 1)
        return null;

    return vars.first();
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
private boolean verifyColumn(Modifiers node) {
    VariableDefinitionEntry var = getPublicStaticFinalStringVar(node);
    if (var == null)
        return false;

    Expression initializer = var.astInitializer();
    if (!(initializer instanceof StringLiteral))
        return false;

    String name = SimplName.from(var.astName().astValue());
    String value = ((StringLiteral) initializer).astValue();

    if (!name.equals(value))
        mContext.report(COLUMN_NAME, node, mContext.getLocation(node.getParent()), "must match " + SimplName.quote(name));

    if (SqlKeywords.contain(name))
        mContext.report(SQL_KEYWORD, mContext.getLocation(var.astName()), "use quoted with ContentValues");

    return true;
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
private boolean verifyConstraint(Modifiers node) {
    VariableDefinitionEntry var = getPublicStaticFinalStringVar(node);
    if (var == null)
        return false;

    Expression initializer = var.astInitializer();
    if (!(initializer instanceof StringLiteral))
        return false;

    String name = SimplName.from(var.astName().astValue());
    String value = ((StringLiteral) initializer).astValue();

    if (!name.equals(value))
        mContext.report(CONSTRAINT_NAME, node, mContext.getLocation(node.getParent()), "must match " + SimplName.quote(name));

    return true;
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Nullable
private static String getLhs(@NonNull MethodInvocation call) {
    Node parent = call.getParent();
    if (parent instanceof Cast) {
        parent = parent.getParent();
    }

    if (parent instanceof VariableDefinitionEntry) {
        VariableDefinitionEntry vde = (VariableDefinitionEntry) parent;
        return vde.astName().astValue();
    } else if (parent instanceof BinaryExpression) {
        BinaryExpression be = (BinaryExpression) parent;
        Expression left = be.astLeft();
        if (left instanceof VariableReference || left instanceof Select) {
            return be.astLeft().toString();
        } else if (left instanceof ArrayAccess) {
            ArrayAccess aa = (ArrayAccess) left;
            return aa.astOperand().toString();
        }
    }

    return null;
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public boolean visitVariableDefinitionEntry(VariableDefinitionEntry node) {
    String name = node.astName().astValue();
    Expression rhs = node.astInitializer();
    Class<?> type = getType(rhs);
    if (type != null) {
        mTypes.put(name, type);
    } else {
        // Make sure we're not visiting the String.format node itself. If you have
        //    msg = String.format("%1$s", msg)
        // then we'd be wiping out the type of "msg" before visiting the
        // String.format call!
        if (rhs != mTargetNode) {
            mTypes.remove(name);
        }
    }

    return super.visitVariableDefinitionEntry(node);
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public boolean visitVariableDefinitionEntry(VariableDefinitionEntry node) {
    Expression initializer = node.astInitializer();
    if (initializer instanceof VariableReference) {
        ResolvedNode resolved = mContext.resolve(initializer);
        //noinspection SuspiciousMethodCalls
        if (resolved != null && mVariables.contains(resolved)) {
            ResolvedNode resolvedVariable = mContext.resolve(node);
            if (resolvedVariable instanceof ResolvedVariable) {
                ResolvedVariable variable = (ResolvedVariable) resolvedVariable;
                mVariables.add(variable);
            } else if (resolvedVariable instanceof ResolvedField) {
                mEscapes = true;
            }
        }
    }
    return super.visitVariableDefinitionEntry(node);
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public boolean visitConstructorDeclaration(ConstructorDeclaration node) {
	for (VariableDefinition variableDefinition : node.astParameters()) {
		if (variableDefinition.astTypeReference().isPrimitive()) {
			// Skip primitive value
			continue;
		}

		Set<String> typeNames = new HashSet<>();
		for (Annotation annotation : variableDefinition.astModifiers().astAnnotations()) {
			typeNames.add(annotation.astAnnotationTypeReference().getTypeName());
		}

		if (typeNames.contains("JsonProperty") && typeNames.contains("NonNull")) {
			VariableDefinitionEntry entry = variableDefinition.astVariables().first();
			if (node.astBody().toString().contains("checkNotNull(" + entry.astName() + ")")) {
				continue;
			}
			mContext.report(ISSUE, mContext.getLocation(variableDefinition), "Should use Precondition.checkNotNull for @NotNull parameters.");
		}
	}

	return false;
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
public void fieldModifiersCheck(VariableDeclaration vd) {
	TypeDeclaration td = vd.upUpToTypeDeclaration();
	if (td == null) return;	//not a field.
	VariableDefinition def = vd.astDefinition();
	if (def != null) {
		Modifiers m = def.astModifiers();
		modifiersCheck(m, FIELD_MODIFIERS_EXCLUSIVITY, FIELD_MODIFIERS_LEGAL, "field declarations");
		boolean allFieldsHaveInitializers = true;
		for (VariableDefinitionEntry entry : def.astVariables()) {
			if (entry.rawInitializer() == null) {
				allFieldsHaveInitializers = false;
				break;
			}
		}
		
		if (m.isStatic() && !m.isFinal() && !allFieldsHaveInitializers) {
			// Initialized static final fields, assuming the initializer expression is a compile time constant, are 'special' and
			// do not need to adhere to the static chain rule. However, we can't determine CTC nature without resolution.
			checkStaticChain(m);
		}
	}
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public boolean visitVariableDefinitionEntry(VariableDefinitionEntry node) {
	formatter.buildInline(node);
	formatter.property("arrayDimensions", node.astArrayDimensions());
	formatter.nameNextElement("varName");
	visit(node.astName());
	for (int i = 0; i < node.astArrayDimensions(); i++)
		formatter.append("[]");
	if (node.rawInitializer() != null) {
		formatter.space();
		formatter.append("=");
		formatter.space();
		visit(node.rawInitializer());
	}
	formatter.closeInline();
	
	return true;
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Test
public void testMethodLocalMaskingTypesMatch() {
	Source s = new Source(METHOD_LOCAL_MASKING_SOURCE, "MaskingTypesMatchTest.java");
	s.parseCompilationUnit();
	final AtomicInteger hit1 = new AtomicInteger();
	final AtomicInteger hit2 = new AtomicInteger();
	s.getNodes().get(0).accept(new ForwardingAstVisitor() {
		@Override public boolean visitVariableDefinitionEntry(VariableDefinitionEntry node) {
			if ("thisIsAUtilList".equals(node.astName().astValue())) {
				assertTrue("thisIsAUtilList isn't matched to java.util.List, but should.",
						new Resolver().typesMatch("java.util.List<?>", node.upToVariableDefinition().astTypeReference()));
				hit1.incrementAndGet();
			}
			if ("butThisIsnt".equals(node.astName().astValue())) {
				assertFalse("butThisIsnt is matched to java.util.List, but shouldn't be.",
						new Resolver().typesMatch("java.util.List<?>", node.upToVariableDefinition().astTypeReference()));
				hit2.incrementAndGet();
			}
			
			return true;
		}
	});
	assertEquals("expected 1 hit on VarDefEntry 'thisIsAUtilList'", 1, hit1.get());
	assertEquals("expected 1 hit on VarDefEntry 'butThisIsnt'", 1, hit2.get());
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public boolean visitVariableDeclaration(VariableDeclaration node) {
    JavaParser.ResolvedNode resolved = mContext.resolve(JavaContext.findSurroundingClass(node));
    JavaParser.ResolvedClass sorroundingClass = (JavaParser.ResolvedClass) resolved;

    if (sorroundingClass.getName().contains(".R.")
            || sorroundingClass.getName().endsWith(".BuildConfig")) {
        return true;
    }

    VariableDefinition definition = node.astDefinition();
    Modifiers modifiers = definition.astModifiers();

    if (modifiers.isStatic() && modifiers.isFinal()){
        StrictListAccessor<VariableDefinitionEntry, VariableDefinition> variableDefinition = definition.astVariables();
        String variableName = variableDefinition.first().astName().toString();
        if (!variableName.equals(variableName.toUpperCase())){
            mContext.report(ISSUE,
                    node,
                    mContext.getLocation(node),
                    "A constant should be named with only UPPER CASE letter and underline.");
        }


    }

    return super.visitVariableDeclaration(node);
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public AstVisitor createJavaVisitor(@NonNull final JavaContext context) {
    return new ForwardingAstVisitor() {

        @Override
        public boolean visitVariableDeclaration(VariableDeclaration node) {

            if (hasClassParent(node) && !PackageManager.isGenerated(context, node)) {

                Node classDeclaration = node.getParent();

                String nodeString = node.toString();

                VariableDefinitionEntry variableDefinition = node.astDefinition().astVariables().first();
                String name = variableDefinition.astName().astValue();

                if (!isStaticOrFinal(node) && !isModel(context, classDeclaration) && !isWidget(nodeString)) {
                    if (!instanceVariableCorrectFormat(name)) {
                        context.report(ISSUE_INSTANCE_VARIABLE_NAME, context.getLocation(node),
                                "Expecting " + name + " to begin with 'm' and be written in camelCase.");
                    }
                } else if (isStaticAndFinal(node)) {
                    if (!staticFinalCorrectFormat(name)) {
                        context.report(ISSUE_CLASS_CONSTANT_NAME, context.getLocation(node),
                                "Expecting " + name + " to be named using UPPER_SNAKE_CASE.");
                    }
                }
            }

            return super.visitVariableDeclaration(node);
        }

    };
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public boolean visitVariableDefinitionEntry(VariableDefinitionEntry node) {
    List<VisitingDetector> list = mNodeTypeDetectors.get(VariableDefinitionEntry.class);
    if (list != null) {
        for (VisitingDetector v : list) {
            v.getVisitor().visitVariableDefinitionEntry(node);
        }
    }
    return false;
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Nullable
@Override
public List<Class<? extends lombok.ast.Node>> getApplicableNodeTypes() {
    List<Class<? extends lombok.ast.Node>> types =
            new ArrayList<Class<? extends lombok.ast.Node>>(2);
    types.add(ImportDeclaration.class);
    types.add(Select.class);
    types.add(MethodDeclaration.class);
    types.add(ConstructorDeclaration.class);
    types.add(VariableDefinitionEntry.class);
    types.add(VariableReference.class);
    types.add(Try.class);
    return types;
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public boolean visitVariableDefinitionEntry(VariableDefinitionEntry node) {
    if (mCurrentMethod != null) {
        if (mLocalVars == null) {
            mLocalVars = Sets.newHashSet();
        }
        mLocalVars.add(node.astName().astValue());
    } else {
        if (mFields == null) {
            mFields = Sets.newHashSet();
        }
        mFields.add(node.astName().astValue());
    }
    return super.visitVariableDefinitionEntry(node);
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public void afterVisitVariableDefinitionEntry(VariableDefinitionEntry node) {
    Expression initializer = node.astInitializer();
    if (initializer != null) {
        ResolvedClass resolvedClass = mTypes.get(initializer);
        if (resolvedClass != null) {
            mTypes.put(node, resolvedClass);
            ResolvedNode variable = mContext.resolve(node);
            if (variable instanceof ResolvedVariable) {
                mVariableTypes.put((ResolvedVariable) variable, resolvedClass);
            }
        }
    }
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Override
public boolean visitVariableReference(VariableReference node) {
    if (node.astIdentifier().astValue().equals(R_CLASS) &&   //$NON-NLS-1$
            node.getParent() instanceof Select &&
            node.getParent().getParent() instanceof Select) {

        // See if we're on the right hand side of an assignment
        lombok.ast.Node current = node.getParent().getParent();
        String reference = ((Select) current).astIdentifier().astValue();

        while (current != mTop && !(current instanceof VariableDefinitionEntry)) {
            if (current == mTargetNode) {
                mName = reference;
                mDone = true;
                return false;
            }
            current = current.getParent();
        }
        if (current instanceof VariableDefinitionEntry) {
            VariableDefinitionEntry entry = (VariableDefinitionEntry) current;
            String variable = entry.astName().astValue();
            mMap.put(variable, reference);
        }
    }

    return false;
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
@Nullable
private static Object getNativeNode(@NonNull Node node) {
    Object nativeNode = node.getNativeNode();
    if (nativeNode != null) {
        return nativeNode;
    }

    Node parent = node.getParent();
    // The ECJ native nodes are sometimes spotty; for example, for a
    // MethodInvocation node we can have a null native node, but its
    // parent expression statement will point to the real MessageSend node
    if (parent != null) {
        nativeNode = parent.getNativeNode();
        if (nativeNode != null) {
            return nativeNode;
        }
    }

    if (node instanceof VariableDefinitionEntry) {
        node = node.getParent().getParent();
    }
    if (node instanceof VariableDeclaration) {
        VariableDeclaration declaration = (VariableDeclaration) node;
        VariableDefinition definition = declaration.astDefinition();
        if (definition != null) {
            lombok.ast.TypeReference typeReference = definition.astTypeReference();
            if (typeReference != null) {
                return typeReference.getNativeNode();
            }
        }
    }

    return null;
}
 

import lombok.ast.VariableDefinitionEntry; //导入依赖的package包/类
private static void check(Object expected, String source, final String targetVariable) {
    JavaContext context = LintUtilsTest.parse(source, new File("src/test/pkg/Test.java"));
    assertNotNull(context);
    CompilationUnit unit = (CompilationUnit) context.getCompilationUnit();
    assertNotNull(unit);

    // Find the expression
    final AtomicReference<Expression> reference = new AtomicReference<Expression>();
    unit.accept(new ForwardingAstVisitor() {
        @Override
        public boolean visitVariableDefinitionEntry(VariableDefinitionEntry node) {
            if (node.astName().astValue().equals(targetVariable)) {
                reference.set(node.astInitializer());
            }
            return super.visitVariableDefinitionEntry(node);
        }
    });
    Expression expression = reference.get();
    Object actual = ConstantEvaluator.evaluate(context, expression);
    if (expected == null) {
        assertNull(actual);
    } else {
        assertNotNull("Couldn't compute value for " + source + ", expected " + expected,
                actual);
        assertEquals(expected.getClass(), actual.getClass());
        assertEquals(expected.toString(), actual.toString());
    }
    assertEquals(expected, actual);
    if (expected instanceof String) {
        assertEquals(expected, ConstantEvaluator.evaluateString(context, expression,
                false));
    }
}