智慧考勤 v1.0.28版本的 MD5 值为:12729d810518c958a6eb8d5a86a946dd
以下内容为反编译后的 EclipseAST.java 源代码,内容仅作参考
package lombok.eclipse;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import lombok.Lombok;
import lombok.core.AST;
import lombok.core.LombokImmutableList;
import lombok.eclipse.handlers.EclipseHandlerUtil;
import lombok.permit.Permit;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
import org.eclipse.jdt.internal.compiler.ast.Initializer;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference;
import org.eclipse.jdt.internal.compiler.ast.ParameterizedSingleTypeReference;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
public class EclipseAST extends AST<EclipseAST, EclipseNode, ASTNode> {
private static volatile boolean skipEclipseWorkspaceBasedFileResolver = false;
private static final URI NOT_CALCULATED_MARKER = URI.create("https://projectlombok.org/not/calculated");
private URI memoizedAbsoluteFileLocation;
private final List<ParseProblem> queuedProblems;
private final CompilationUnitDeclaration compilationUnitDeclaration;
private boolean completeParse;
private static int[] $SWITCH_TABLE$lombok$core$AST$Kind;
static int[] $SWITCH_TABLE$lombok$core$AST$Kind() {
int[] iArr = $SWITCH_TABLE$lombok$core$AST$Kind;
if (iArr != null) {
return iArr;
}
int[] iArr2 = new int[AST.Kind.valuesCustom().length];
try {
iArr2[AST.Kind.ANNOTATION.ordinal()] = 6;
} catch (NoSuchFieldError unused) {
}
try {
iArr2[AST.Kind.ARGUMENT.ordinal()] = 7;
} catch (NoSuchFieldError unused2) {
}
try {
iArr2[AST.Kind.COMPILATION_UNIT.ordinal()] = 1;
} catch (NoSuchFieldError unused3) {
}
try {
iArr2[AST.Kind.FIELD.ordinal()] = 3;
} catch (NoSuchFieldError unused4) {
}
try {
iArr2[AST.Kind.INITIALIZER.ordinal()] = 4;
} catch (NoSuchFieldError unused5) {
}
try {
iArr2[AST.Kind.LOCAL.ordinal()] = 8;
} catch (NoSuchFieldError unused6) {
}
try {
iArr2[AST.Kind.METHOD.ordinal()] = 5;
} catch (NoSuchFieldError unused7) {
}
try {
iArr2[AST.Kind.STATEMENT.ordinal()] = 9;
} catch (NoSuchFieldError unused8) {
}
try {
iArr2[AST.Kind.TYPE.ordinal()] = 2;
} catch (NoSuchFieldError unused9) {
}
try {
iArr2[AST.Kind.TYPE_USE.ordinal()] = 10;
} catch (NoSuchFieldError unused10) {
}
$SWITCH_TABLE$lombok$core$AST$Kind = iArr2;
return iArr2;
}
public EclipseAST(CompilationUnitDeclaration ast) {
super(toFileName(ast), packageDeclaration(ast), new EclipseImportList(ast), statementTypes());
this.memoizedAbsoluteFileLocation = NOT_CALCULATED_MARKER;
this.queuedProblems = new ArrayList();
this.compilationUnitDeclaration = ast;
setTop(buildCompilationUnit(ast));
this.completeParse = isComplete(ast);
clearChanged();
}
public static URI getAbsoluteFileLocation(CompilationUnitDeclaration ast) {
return getAbsoluteFileLocation0(ast);
}
@Override
public URI getAbsoluteFileLocation() {
if (this.memoizedAbsoluteFileLocation != NOT_CALCULATED_MARKER) {
return this.memoizedAbsoluteFileLocation;
}
this.memoizedAbsoluteFileLocation = getAbsoluteFileLocation0(this.compilationUnitDeclaration);
return this.memoizedAbsoluteFileLocation;
}
private static URI getAbsoluteFileLocation0(CompilationUnitDeclaration ast) {
String fileName = toFileName(ast);
if (fileName != null && (fileName.startsWith("file:") || fileName.startsWith("sourcecontrol:"))) {
return URI.create(fileName);
}
if (!skipEclipseWorkspaceBasedFileResolver) {
try {
try {
return EclipseWorkspaceBasedFileResolver.resolve(fileName);
} catch (IllegalArgumentException e) {
EclipseHandlerUtil.warning("Finding 'lombok.config' file failed for '" + fileName + "'", e);
}
} catch (NoClassDefFoundError unused) {
skipEclipseWorkspaceBasedFileResolver = true;
}
}
try {
return new File(fileName).getAbsoluteFile().toURI();
} catch (Exception unused2) {
return null;
}
}
public static class EclipseWorkspaceBasedFileResolver {
private EclipseWorkspaceBasedFileResolver() {
}
public static URI resolve(String path) {
if (path == null || path.indexOf(47, 1) == -1) {
return null;
}
try {
return ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(path)).getLocationURI();
} catch (Exception unused) {
return null;
}
}
}
private static String packageDeclaration(CompilationUnitDeclaration cud) {
ImportReference pkg = cud.currentPackage;
if (pkg == null) {
return null;
}
return Eclipse.toQualifiedName(pkg.getImportName());
}
@Override
public int getSourceVersion() {
long sl = this.compilationUnitDeclaration.problemReporter.options.sourceLevel;
long sl2 = sl >> 16;
long cl = this.compilationUnitDeclaration.problemReporter.options.complianceLevel >> 16;
if (sl2 == 0) {
sl2 = cl;
}
if (cl == 0) {
cl = sl2;
}
return Math.min((int) (sl2 - 44), (int) (cl - 44));
}
@Override
public int getLatestJavaSpecSupported() {
return Eclipse.getEcjCompilerVersion();
}
public void traverse(EclipseASTVisitor visitor) {
top().traverse(visitor);
}
public void traverseChildren(EclipseASTVisitor visitor, EclipseNode node) {
LombokImmutableList<EclipseNode> children = node.down();
int len = children.size();
for (int i = 0; i < len; i++) {
children.get(i).traverse(visitor);
}
}
public boolean isCompleteParse() {
return this.completeParse;
}
public class ParseProblem {
final boolean isWarning;
final String message;
final int sourceStart;
final int sourceEnd;
public ParseProblem(boolean isWarning, String message, int sourceStart, int sourceEnd) {
this.isWarning = isWarning;
this.message = message;
this.sourceStart = sourceStart;
this.sourceEnd = sourceEnd;
}
void addToCompilationResult() {
CompilationUnitDeclaration cud = EclipseAST.this.top().get();
EclipseAST.addProblemToCompilationResult(cud.getFileName(), cud.compilationResult, this.isWarning, this.message, this.sourceStart, this.sourceEnd);
}
}
private void propagateProblems() {
if (this.queuedProblems.isEmpty()) {
return;
}
CompilationUnitDeclaration cud = top().get();
if (cud.compilationResult == null) {
return;
}
for (ParseProblem problem : this.queuedProblems) {
problem.addToCompilationResult();
}
this.queuedProblems.clear();
}
public void addProblem(ParseProblem problem) {
this.queuedProblems.add(problem);
propagateProblems();
}
public static void addProblemToCompilationResult(char[] fileNameArray, CompilationResult result, boolean isWarning, String message, int sourceStart, int sourceEnd) {
try {
EcjReflectionCheck.addProblemToCompilationResult.invoke(null, fileNameArray, result, Boolean.valueOf(isWarning), message, Integer.valueOf(sourceStart), Integer.valueOf(sourceEnd));
} catch (IllegalAccessException e) {
throw Lombok.sneakyThrow(e);
} catch (NoClassDefFoundError unused) {
} catch (NullPointerException e2) {
if (!"false".equals(System.getProperty("lombok.debug.reflection", "false"))) {
e2.initCause(EcjReflectionCheck.problemAddProblemToCompilationResult);
throw e2;
}
} catch (InvocationTargetException e3) {
throw Lombok.sneakyThrow(e3);
}
}
public static Annotation[] getTopLevelTypeReferenceAnnotations(TypeReference tr) {
Annotation[][] annss;
Method m = EcjReflectionCheck.typeReferenceGetAnnotationsOnDimensions;
if (m == null) {
return null;
}
try {
Annotation[][] annss2 = (Annotation[][]) m.invoke(tr, new Object[0]);
if (annss2 != null) {
return annss2[0];
}
} catch (Throwable unused) {
}
try {
Field f = EcjReflectionCheck.typeReferenceAnnotations;
if (f == null || (annss = (Annotation[][]) f.get(tr)) == null) {
return null;
}
return annss[annss.length - 1];
} catch (Throwable unused2) {
return null;
}
}
private static String toFileName(CompilationUnitDeclaration ast) {
if (ast.compilationResult.fileName == null) {
return null;
}
return new String(ast.compilationResult.fileName);
}
public void rebuild(boolean force) {
propagateProblems();
if (!this.completeParse || force) {
boolean changed = isChanged();
boolean newCompleteParse = isComplete(this.compilationUnitDeclaration);
if (newCompleteParse || force) {
top().rebuild();
this.completeParse = newCompleteParse;
if (!changed) {
clearChanged();
}
}
}
}
public static boolean isComplete(CompilationUnitDeclaration unit) {
return (unit.bits & 16) != 0;
}
@Override
public EclipseNode buildTree(ASTNode node, AST.Kind kind) {
switch ($SWITCH_TABLE$lombok$core$AST$Kind()[kind.ordinal()]) {
case 1:
return buildCompilationUnit((CompilationUnitDeclaration) node);
case 2:
return buildType((TypeDeclaration) node);
case 3:
return buildField((FieldDeclaration) node);
case 4:
return buildInitializer((Initializer) node);
case 5:
return buildMethod((AbstractMethodDeclaration) node);
case 6:
return buildAnnotation((Annotation) node, false);
case 7:
return buildLocal((Argument) node, kind);
case 8:
return buildLocal((LocalDeclaration) node, kind);
case 9:
return buildStatement((Statement) node);
case 10:
return buildTypeUse((TypeReference) node);
default:
throw new AssertionError("Did not expect to arrive here: " + kind);
}
}
private EclipseNode buildCompilationUnit(CompilationUnitDeclaration top) {
if (setAndGetAsHandled(top)) {
return null;
}
List<EclipseNode> children = buildTypes(top.types);
return putInMap(new EclipseNode(this, top, children, AST.Kind.COMPILATION_UNIT));
}
private void addIfNotNull(Collection<EclipseNode> collection, EclipseNode n) {
if (n != null) {
collection.add(n);
}
}
private List<EclipseNode> buildTypes(TypeDeclaration[] children) {
List<EclipseNode> childNodes = new ArrayList<>();
if (children != null) {
for (TypeDeclaration type : children) {
addIfNotNull(childNodes, buildType(type));
}
}
return childNodes;
}
private EclipseNode buildType(TypeDeclaration type) {
if (setAndGetAsHandled(type)) {
return null;
}
List<EclipseNode> childNodes = new ArrayList<>();
childNodes.addAll(buildFields(type.fields));
childNodes.addAll(buildTypes(type.memberTypes));
childNodes.addAll(buildMethods(type.methods));
childNodes.addAll(buildAnnotations(type.annotations, false));
return putInMap(new EclipseNode(this, type, childNodes, AST.Kind.TYPE));
}
private Collection<EclipseNode> buildFields(FieldDeclaration[] children) {
List<EclipseNode> childNodes = new ArrayList<>();
if (children != null) {
for (FieldDeclaration child : children) {
addIfNotNull(childNodes, buildField(child));
}
}
return childNodes;
}
private static <T> List<T> singleton(T item) {
List<T> list = new ArrayList<>();
if (item != null) {
list.add(item);
}
return list;
}
private EclipseNode buildField(FieldDeclaration field) {
if (field instanceof Initializer) {
return buildInitializer((Initializer) field);
}
if (setAndGetAsHandled(field)) {
return null;
}
List<EclipseNode> childNodes = new ArrayList<>();
addIfNotNull(childNodes, buildTypeUse(field.type));
addIfNotNull(childNodes, buildStatement(field.initialization));
childNodes.addAll(buildAnnotations(field.annotations, true));
return (EclipseNode) putInMap(new EclipseNode(this, field, childNodes, AST.Kind.FIELD));
}
private EclipseNode buildInitializer(Initializer initializer) {
if (setAndGetAsHandled(initializer)) {
return null;
}
return putInMap(new EclipseNode(this, initializer, singleton(buildStatement(initializer.block)), AST.Kind.INITIALIZER));
}
private Collection<EclipseNode> buildMethods(AbstractMethodDeclaration[] children) {
List<EclipseNode> childNodes = new ArrayList<>();
if (children != null) {
for (AbstractMethodDeclaration method : children) {
addIfNotNull(childNodes, buildMethod(method));
}
}
return childNodes;
}
private EclipseNode buildMethod(AbstractMethodDeclaration method) {
if (setAndGetAsHandled(method)) {
return null;
}
List<EclipseNode> childNodes = new ArrayList<>();
childNodes.addAll(buildArguments(method.arguments));
if (method instanceof ConstructorDeclaration) {
ConstructorDeclaration constructor = (ConstructorDeclaration) method;
addIfNotNull(childNodes, buildStatement(constructor.constructorCall));
}
childNodes.addAll(buildStatements(method.statements));
childNodes.addAll(buildAnnotations(method.annotations, false));
return (EclipseNode) putInMap(new EclipseNode(this, method, childNodes, AST.Kind.METHOD));
}
private Collection<EclipseNode> buildArguments(Argument[] children) {
List<EclipseNode> childNodes = new ArrayList<>();
if (children != null) {
for (Argument argument : children) {
addIfNotNull(childNodes, buildLocal(argument, AST.Kind.ARGUMENT));
}
}
return childNodes;
}
private EclipseNode buildLocal(LocalDeclaration local, AST.Kind kind) {
if (setAndGetAsHandled(local)) {
return null;
}
List<EclipseNode> childNodes = new ArrayList<>();
addIfNotNull(childNodes, buildTypeUse(local.type));
addIfNotNull(childNodes, buildStatement(local.initialization));
childNodes.addAll(buildAnnotations(local.annotations, true));
return (EclipseNode) putInMap(new EclipseNode(this, local, childNodes, kind));
}
private EclipseNode buildTypeUse(TypeReference tr) {
TypeReference bound;
TypeReference[] typeReferenceArr;
if (setAndGetAsHandled(tr) || tr == null) {
return null;
}
List<EclipseNode> childNodes = new ArrayList<>();
Annotation[] anns = getTopLevelTypeReferenceAnnotations(tr);
if (anns != null) {
for (Annotation ann : anns) {
addIfNotNull(childNodes, buildAnnotation(ann, false));
}
}
if (tr instanceof ParameterizedQualifiedTypeReference) {
ParameterizedQualifiedTypeReference pqtr = (ParameterizedQualifiedTypeReference) tr;
int len = pqtr.tokens.length;
for (int i = 0; i < len; i++) {
TypeReference[] typeArgs = pqtr.typeArguments[i];
if (typeArgs != null) {
for (TypeReference tArg : typeArgs) {
addIfNotNull(childNodes, buildTypeUse(tArg));
}
}
}
} else if (tr instanceof ParameterizedSingleTypeReference) {
ParameterizedSingleTypeReference pstr = (ParameterizedSingleTypeReference) tr;
if (pstr.typeArguments != null) {
for (TypeReference tArg2 : pstr.typeArguments) {
addIfNotNull(childNodes, buildTypeUse(tArg2));
}
}
} else if ((tr instanceof Wildcard) && (bound = ((Wildcard) tr).bound) != null) {
addIfNotNull(childNodes, buildTypeUse(bound));
}
return (EclipseNode) putInMap(new EclipseNode(this, tr, childNodes, AST.Kind.TYPE_USE));
}
private Collection<EclipseNode> buildAnnotations(Annotation[] annotations, boolean varDecl) {
List<EclipseNode> elements = new ArrayList<>();
if (annotations != null) {
for (Annotation an : annotations) {
addIfNotNull(elements, buildAnnotation(an, varDecl));
}
}
return elements;
}
private EclipseNode buildAnnotation(Annotation annotation, boolean field) {
if (annotation == null) {
return null;
}
boolean handled = setAndGetAsHandled(annotation);
if (!field && handled) {
return null;
}
return putInMap(new EclipseNode(this, annotation, null, AST.Kind.ANNOTATION));
}
private Collection<EclipseNode> buildStatements(Statement[] children) {
List<EclipseNode> childNodes = new ArrayList<>();
if (children != null) {
for (Statement child : children) {
addIfNotNull(childNodes, buildStatement(child));
}
}
return childNodes;
}
private EclipseNode buildStatement(Statement child) {
if (child == null) {
return null;
}
if (child instanceof TypeDeclaration) {
return buildType((TypeDeclaration) child);
}
if (child instanceof LocalDeclaration) {
return buildLocal((LocalDeclaration) child, AST.Kind.LOCAL);
}
if (setAndGetAsHandled(child)) {
return null;
}
return drill(child);
}
private EclipseNode drill(Statement statement) {
AST.FieldAccess[] fieldsOf;
List<EclipseNode> childNodes = new ArrayList<>();
for (AST.FieldAccess fa : fieldsOf(statement.getClass())) {
childNodes.addAll(buildWithField(EclipseNode.class, statement, fa));
}
return putInMap(new EclipseNode(this, statement, childNodes, AST.Kind.STATEMENT));
}
private static Collection<Class<? extends ASTNode>> statementTypes() {
return Collections.singleton(Statement.class);
}
public static class EcjReflectionCheck {
private static final String COMPILATIONRESULT_TYPE = "org.eclipse.jdt.internal.compiler.CompilationResult";
public static final Method addProblemToCompilationResult;
public static final Throwable problemAddProblemToCompilationResult;
public static final Method typeReferenceGetAnnotationsOnDimensions;
public static final Field typeReferenceAnnotations;
private EcjReflectionCheck() {
}
static {
Method m2;
Field f;
Throwable problem_ = null;
Method m1 = null;
try {
m1 = Permit.getMethod(EclipseAstProblemView.class, "addProblemToCompilationResult", char[].class, Class.forName(COMPILATIONRESULT_TYPE), Boolean.TYPE, String.class, Integer.TYPE, Integer.TYPE);
} catch (Throwable t) {
problem_ = t;
}
try {
m2 = Permit.getMethod(TypeReference.class, "getAnnotationsOnDimensions", new Class[0]);
} catch (Throwable unused) {
m2 = null;
}
try {
f = Permit.getField(TypeReference.class, "annotations");
} catch (Throwable unused2) {
f = null;
}
addProblemToCompilationResult = m1;
problemAddProblemToCompilationResult = problem_;
typeReferenceGetAnnotationsOnDimensions = m2;
typeReferenceAnnotations = f;
}
}
}