我是AST的新手(我第一次写插件)。现实生活中的表达可能会非常复杂。例如,我想知道如何解决作业的左侧和右侧。

class Visitor extends ASTVisitor
{
    @Override
    public boolean visit(Assignment node)
    {
        //here, how do I get the final name to each each side of the assignment resolves?
    }
}

我还有另一个疑问,如何获得用于调用方法的实例?
public boolean visit(MethodInvocation node)
{
    //how do I get to know the object used to invoke this method?
    //like, for example, MyClass is a class, and it has a field called myField
    //the type of myField has a method called myMethod.
    //how do I find myField? or for that matter some myLocalVariable used in the same way.
}

假设以下分配
SomeType.someStaticMethod(params).someInstanceMethod(moreParams).someField =
     [another expression with arbitrary complexity]

如何从someField节点获取Assigment

而且,MethodInvocation的什么属性为我提供了用于调用该方法的实例?

编辑1:鉴于我收到的答案,我的问题显然不清楚。我不想解决这个特定表达式。我希望能够在给定任何分配后,找出分配给它的名称,以及分配给第一个名称的名称(如果不是右值)。

因此,例如,方法调用的参数可以是字段访问或先前声明的局部变量。
SomeType.someStaticMethod(instance.field).someInstanceMethod(type.staticField, localVariable, localField).Field.destinationField

因此,这是一个充满希望的客观问题:给定左侧和右侧都具有任意复杂度的任何赋值语句,如何获取要赋值的最终字段/变量,以及赋值的最终(如果有的话)字段/变量做到这一点。

编辑2:更具体地说,我想通过注解@Const实现不变性:
/**
* When Applied to a method, ensures the method doesn't change in any
* way the state of the object used to invoke it, i.e., all the fields
* of the object must remain the same, and no field may be returned,
* unless the field itself is marked as {@code @Const} or the field is
* a primitive non-array type. A method  annotated with {@code @Const}
* can only invoke other {@code @Const} methods of its class, can only
* use the class's fields to invoke {@code @Const} methods of the fields
* classes and can only pass fields as parameters to methods that
* annotate that formal parameter as {@code @Const}.
*
* When applied to a formal parameter, ensures the method will not
* modify the value referenced by the formal parameter. A formal
* parameter annotated as {@code @Const} will not be aliased inside the
* body of the method. The method is not allowed to invoke another
* method and pass the annotated parameter, save if the other method
* also annotates the formal parameter as {@code @Const}. The method is
* not allowed to use the parameter to invoke any of its type's methods,
* unless the method being invoked is also annotated as {@code @Const}
*
* When applied to a field, ensures the field cannot be aliased and that
* no code can alter the state of that field, either from inside the
* class that owns the field or from outside it. Any constructor in any
* derived class is allowed to set the value of the field and invoke any
* methods using it. As for methods, only those annotated as
* {@code @Const} may be invoked using the field. The field may only be
* passed as a parameter to a method if the method annotates the
* corresponding formal parameter as {@code @Const}
*
* When applied to a local variable, ensures neither the block where the
* variable is declared or any nested block will alter the value of that
* local variable. The local variable may be defined only once, at any
* point where it is in scope and cannot be aliased. Only methods
* annotated as {@code @Const} may be invoked using this variable, and
* the variable  may only be passed as a parameter to another method if
* said method annotates its corresponding formal parameter as
* {@code @Const}
*
*/
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD,
ElementType.LOCAL_VARIABLE})
@Inherited
public @interface Const
{

}

为此,我要做的第一件事是将作业的左侧标记为@Const(很容易)的情况。我还必须检测何时expression的右侧是标记为@Const的字段,在这种情况下,只能在定义相同类型的@Const变量时将其赋值。

问题是我很难在表达式的右侧找到最终字段,以避免别名该字段并使@Const注释无用。

最佳答案

访客是一个非常好的工具,但是解决特定问题的适当解决方案并不总是让单个访客耐心等待,直到其访问方法被调用...您要问的问题就是这种情况的一个例子。

让我们改写您想做的事情:

  • 您要标识以标识每个分配(即leftSide = rightSide)
  • 对于每个分配,您要确定左侧的性质(即它是局部变量还是字段访问),如果确实是字段访问,则要构建一个“路径”对应的到该字段(即源对象,然后是一系列方法调用或字段访问,并以字段访问结尾)。
  • 对于每个分配,您都希望确定一个与右侧相对应的类似“路径”。

  • 我认为您已经解决了第1点:您只需创建一个扩展org.eclipse.jdt.core.dom.ASTVisitor的类;在那里,您覆盖了#visit(Assignment)方法。最后,在适当的地方,实例化您的访问者类,并让它访问AST树,从任何与您的需求相匹配的节点(最可能是CompilationUnitTypeDeclarationMethodDeclaration的实例)开始。

    那怎么了#visit(Assignment)方法确实接收一个Assignment节点。直接在该对象上,您可以同时获得左侧和右侧的表达式(assignment.getLeftHandSide()assignment.getRightHandSide())。正如您提到的,它们都是Expression,它们可能非常复杂,因此我们如何从这些子树中提取干净的线性“路径”呢?一个访问者当然是最好的方法,但这是要捕获的地方,应该使用不同的访问者来完成,而不是让您的第一个访问者(一个正在捕获的Assignment)继续其后侧表达式。从技术上讲,可以使用单个访问者来完成所有操作,但是这将涉及该访问者内部的重要状态管理。无论如何,我几乎确信,这种管理的复杂性将是如此之高,以至于这种实现的效率实际上不如独特的访客方法。

    这样我们就可以像这样成像:
    class MyAssignmentListVisitor extends ASTVisitor {
        @Override
        public boolean visit(Assignment assignment) {
            FieldAccessLineralizationVisitor leftHandSideVisitor = new FieldAccessLineralizationVisitor();
            assignment.getLeftHandSide().accept(leftHandSideVisitor);
            LinearFieldAccess leftHandSidePath = leftHandSideVisitor.asLinearFieldAccess();
    
            FieldAccessLineralizationVisitor rightHandSideVisitor = new FieldAccessLineralizationVisitor();
            assignment.getRightHandSide().accept(rightHandSideVisitor);
            LinearFieldAccess rightHandSidePath = rightHandSideVisitor.asLinearFieldAccess();
    
            processAssigment(leftHandSidePath, rightHandSidePath);
    
            return true;
        }
    }
    
    class FieldAccessLineralizationVisitor extends ASTVisitor {
    
        List<?> significantFieldAccessParts = [...];
    
        // ... various visit method expecting concrete subtypes of Expression ...
    
        @Override
        public boolean visit(Assignment assignment) {
            // Found an assignment inside an assignment; ignore its
            // left hand side, as it does not affect the "path" for
            // the assignment currently being investigated
    
            assignment.getRightHandSide().accept(this);
    
            return false;
        }
    }
    

    请注意,在此代码中MyAssignmentListVisitor.visit(Assignment)返回true,以指示应递归检查赋值的子代。起初这听起来似乎是不必要的,Java语言确实支持几种结构,其中一个分配可以包含其他分配。例如考虑以下极端情况:
    (varA = someObject).someField = varB = (varC = new SomeClass(varD = "string").someField);
    

    出于相同的原因,假定赋值的“结果值”是其赋值的右侧,则在表达式的线性化期间仅访问赋值的右侧。在这种情况下,左侧仅是可以安全忽略的副作用。

    考虑到我不了解您的特定情况所需的信息的性质,我将不对原型(prototype)实际如何建模进行任何进一步的介绍。您也可能更适合分别为左侧表达式和右侧表达式创建不同的访问者类,例如,以更好地处理以下事实:右侧可能实际上涉及多个变量/字段/方法调用的组合通过二进制运算符。那将是你的决定。

    关于要遍历AST树的访客遍历仍然存在一些主要问题,即,通过依赖默认的节点遍历顺序,您就失去了获取有关每个节点之间关系的信息的机会。例如,给定表达式this.someMethod(this.fieldA).fieldB,您将看到类似于以下序列的内容:
    FieldAccess      => corresponding to the whole expression
    MethodInvovation => corresponding to this.someMethod(this.fieldA)
    ThisExpression
    SimpleName ("someMethod")
    FieldAccess      => corresponding to this.fieldA
    ThisExpression
    SimpleName ("fieldA")
    SimpleName ("fieldB")
    

    实际上,您根本无法从该事件序列中推断出线性化表达式。相反,您将希望显式地拦截每个节点,并且仅在适当时且以适当的顺序在节点的子级上显式递归。例如,我们可以完成以下操作:
        @Override
        public boolean visit(FieldAccess fieldAccess) {
            // FieldAccess :: <expression>.<name>
    
            // First descend on the "subject" of the field access
            fieldAccess.getExpression().accept(this);
    
            // Then append the name of the accessed field itself
            this.path.append(fieldAccess.getName().getIdentifier());
    
            return false;
        }
    
        @Override
        public boolean visit(MethodInvocation methodInvocation) {
            // MethodInvocation :: <expression>.<methodName><<typeArguments>>(arguments)
    
            // First descend on the "subject" of the method invocation
            methodInvocation.getExpression().accept(this);
    
            // Then append the name of the accessed field itself
            this.path.append(methodAccess.getName().getIdentifier() + "()");
    
            return false;
        }
    
        @Override
        public boolean visit(ThisExpression thisExpression) {
            // ThisExpression :: [<qualifier>.] this
    
            // I will ignore the qualifier part for now, it will be up
            // to you to determine if it is pertinent
            this.path.append("this");
    
            return false;
        }
    

    在前面的示例中,这些方法将按以下顺序在path中收集:thissomeMethod()fieldB。我相信,这与您要寻找的非常接近。如果您想收集所有字段访问/方法调用序列(例如,您希望访问者同时返回this,someMethod(),fieldBthis,fieldA),则可以大致类似于以下方式重写visit(MethodInvocation)方法:
        @Override
        public boolean visit(MethodInvocation methodInvocation) {
            // MethodInvocation :: <expression>.<methodName><<typeArguments>>(arguments)
    
            // First descend on the "subject" of the method invocation
            methodInvocation.getExpression().accept(this);
    
            // Then append the name of the accessed field itself
            this.path.append(methodAccess.getName().getIdentifier() + "()");
    
            // Now deal with method arguments, each within its own, distinct access chain
            for (Expression arg : methodInvocation.getArguments()) {
                LinearPath orginalPath = this.path;
                this.path = new LinearPath();
    
                arg.accept(this);
    
                this.collectedPaths.append(this.path);
                this.path = originalPath;
            }
    
            return false;
        }
    

    最后,如果您想了解路径中每个步骤的值类型,则必须查看与每个节点关联的绑定(bind)对象,例如:methodInvocation.resolveMethodBinding().getDeclaringClass()。但是请注意,必须在构造AST树时明确请求绑定(bind)解析。

    上面的代码将无法正确处理更多的语言构造。不过,我相信您应该可以自己解决剩余的问题。如果需要引用实现,请查看org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFlattener类,该类基本上是从现有AST树中重构Java源代码的;尽管这个特定的访问者比大多数其他ASTVisitor大得多,但它更容易理解。

    更新以回应OP的编辑#2

    这是您最近编辑后的更新起点。仍然有许多情况要处理,但这与您的特定问题更加吻合。还要注意,尽管我使用了许多instanceof检查(因为这对我来说现在比较容易,因为我正在用一个简单的文本编辑器编写代码,并且对ASTNode常量没有代码完成),所以您可以选择使用在node.getNodeType()上的switch语句,通常会更有效。
    class ConstCheckVisitor extends ASTVisitor {
    
        @Override
        public boolean visit(MethodInvocation methodInvocation) {
            if (isConst(methodInvocation.getExpression())) {
                if (isConst(methodInvocation.resolveMethodBinding().getMethodDeclaration()))
                    reportInvokingNonConstMethodOnConstSubject(methodInvocation);
            }
    
            return true;
        }
    
        @Override
        public boolean visit(Assignment assignment) {
            if (isConst(assignment.getLeftHandSide())) {
                if ( /* assignment to @Const value is not acceptable in the current situation */ )
                    reportAssignmentToConst(assignment.getLeftHandSide());
    
                // FIXME: I assume here that aliasing a @Const value to
                //        another @Const value is acceptable. Is that right?
    
            } else if (isImplicitelyConst(assigment.getLeftHandSide())) {
                reportAssignmentToImplicitConst(assignment.getLeftHandSide());
    
            } else if (isConst(assignment.getRightHandSide())) {
                reportAliasing(assignment.getRightHandSide());
            }
    
            return true;
        }
    
        private boolean isConst(Expression expression) {
            if (expression instanceof FieldAccess)
                return (isConst(((FieldAccess) expression).resolveFieldBinding()));
    
            if (expression instanceof SuperFieldAccess)
                return isConst(((SuperFieldAccess) expression).resolveFieldBinding());
    
            if (expression instanceof Name)
                return isConst(((Name) expression).resolveBinding());
    
            if (expression instanceof ArrayAccess)
                return isConst(((ArrayAccess) expression).getArray());
    
            if (expression instanceof Assignment)
                return isConst(((Assignment) expression).getRightHandSide());
    
            return false;
        }
    
        private boolean isImplicitConst(Expression expression) {
            // Check if field is actually accessed through a @Const chain
            if (expression instanceof FieldAccess)
                return isConst((FieldAccess expression).getExpression()) ||
                       isimplicitConst((FieldAccess expression).getExpression());
    
            // FIXME: Not sure about the effect of MethodInvocation, assuming
            //        that its subject is const or implicitly const
    
            return false;
        }
    
        private boolean isConst(IBinding binding) {
            if ((binding instanceof IVariableBinding) || (binding instanceof IMethodBinding))
                return containsConstAnnotation(binding.getAnnotations());
    
            return false;
        }
    }
    

    希望能有所帮助。

    10-07 13:27
    查看更多