JavaParser中AST节点的观察者

我们离JavaParser 3.0的第一个候选发布版本越来越近。 我们添加的最后一项功能是支持观察抽象语法树的所有节点的更改。 当我为此功能编写代码时，我收到了Danny van Bruggen（又名Matozoid）和Cruz Maximilien的宝贵反馈。 因此，我使用“我们”来指代JavaParser团队。

AST节点上的哪些观察者可以用于？

我认为这对于JavaParser的生态系统来说是非常重要的功能，因为它通过对AST所做的更改做出反应，使与JavaParser的集成变得更加容易。 可以观察到的可能更改是为类设置新名称或添加新字段。 不同的工具可以以不同的方式对这些变化做出反应。 例如：

• 编辑者可以更新其符号列表，该列表可用于自动完成等操作
• 一些框架可以重新生成源代码以反映更改
• 可以执行验证以验证新更改是否导致无效的AST
• 像JavaSymbolSolver这样的库可以重新计算表达式的类型

这些只是我想到的一些想法，但我认为使用JavaParser的大多数方案都可以从对更改做出反应的可能性中受益。

AstObserver

JavaParser 3.0 AST基于Nodes和NodeLists。 节点（例如，如TypeDeclaration）可以具有不同的子组。 当这些组可以包含多个节点时，我们使用NodeLists。 例如，一个TypeDeclarations可以具有多个成员（字段，方法，内部类）。 因此，每个TypeDeclaration都有一个NodeList来包含字段，一个NodeList来包含方法，等等。其他子项（如TypeDeclaration的名称）则直接包含在节点中。

我们引入了一个名为AstObserver的新接口。 AstObserver接收节点和NodeList上的更改。

/**
 * An Observer for an AST element (either a Node or a NodeList).
 */
public interface AstObserver {
 
    /**
     * Type of change occurring on a List
     */
    public enum ListChangeType {
        ADDITION,
        REMOVAL
    }
 
    /**
     * The value of a property is changed
     *
     * @param observedNode owner of the property
     * @param property property changed
     * @param oldValue value of the property before the change
     * @param newValue value of the property after the change
     */
    void propertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue);
 
    /**
     * The parent of a node is changed
     *
     * @param observedNode node of which the parent is changed
     * @param previousParent previous parent
     * @param newParent new parent
     */
    void parentChange(Node observedNode, Node previousParent, Node newParent);
 
    /**
     * A list is changed
     *
     * @param observedNode list changed
     * @param type type of change
     * @param index position at which the changed occurred
     * @param nodeAddedOrRemoved element added or removed
     */
    void listChange(NodeList observedNode, ListChangeType type, int index, Node nodeAddedOrRemoved);
}

观察什么

现在我们有了一个AstObserver ，我们需要决定应该接收哪些更改。 我们考虑了三种可能的情况：

1. 仅观察一个节点，例如ClassDeclaration。 观察者将收到有关该节点上的更改的通知（例如，如果类更改名称），而不是其任何后代的通知。 例如，如果类更改名称的字段不会通知观察者
2. 对于观察者注册时的节点及其所有后代。 在这种情况下，如果我注册了ClassDeclaration的观察者，则将通知我有关类及其所有字段和方法的更改。 如果添加了新字段，后来又进行了修改，那么我将不会收到有关这些更改的通知
3. 对于一个节点及其所有后代，在观察者注册时存在的节点和以后添加的节点。

因此，节点现在具有此方法：

/**
     * Register a new observer for the given node. Depending on the mode specified also descendants, existing
     * and new, could be observed. For more details seeObserverRegistrationMode .
     */
    public void register(AstObserver observer, ObserverRegistrationMode mode) {
        if (mode == null) {
            throw new IllegalArgumentException("Mode should be not null");
        }
        switch (mode) {
            case JUST_THIS_NODE:
                register(observer);
                break;
            case THIS_NODE_AND_EXISTING_DESCENDANTS:
                registerForSubtree(observer);
                break;
            case SELF_PROPAGATING:
                registerForSubtree(PropagatingAstObserver.transformInPropagatingObserver(observer));
                break;
            default:
                throw new UnsupportedOperationException("This mode is not supported: " + mode);
        }
    }

为了区分这三种情况，我们仅使用一个枚举（ ObserverRegistrationMode ）。 稍后，您将看到我们如何实现PropagatingAstObserver 。

实施对观察员的支持

如果JavaParser基于诸如EMF之类的元建模框架，则这将非常简单。 鉴于情况并非如此，我需要在AST类的所有设置器中添加一个通知调用（其中有90个左右）。

因此，在特定节点上调用setter时，它将通知所有观察者。 简单。 以TypeDeclaration <T>中的 setName 为例 ：

@Override
public T setName(SimpleName name) {
    notifyPropertyChange(ObservableProperty.NAME, this.name, name);
    this.name = assertNotNull(name);
    setAsParentNodeOf(name);
    return (T) this;
}

给定我们没有适当的元模型，就没有属性的定义。 因此，我们在枚举中添加了一个名为ObservableProperty的属性列表。 通过这种方式，观察者可以检查更改了哪个属性并决定如何做出反应。

观察者的内部等级

出于性能原因，每个节点都有其自己的观察者列表。 当我们要观察节点的所有后代时，我们只需向该子树中的所有节点和节点列表添加相同的观察者即可。

但是，这还不够，因为在某些情况下，您可能还需要观察放置观察者后添加到子树中的所有节点。 我们通过使用PropagatingAstObserver做到这一点。 这是一个AstObserver，当看到一个新节点已附加到该节点时，它也开始观察该新节点。 简单吧？

/**
 * This AstObserver attach itself to all new nodes added to the nodes already observed.
 */
public abstract class PropagatingAstObserver implements AstObserver {
 
    /**
     * Wrap a given observer to make it self-propagating. If the given observer is an instance of PropagatingAstObserver
     * the observer is returned without changes.
     */
    public static PropagatingAstObserver transformInPropagatingObserver(final AstObserver observer) {
        if (observer instanceof PropagatingAstObserver) {
            return (PropagatingAstObserver)observer;
        }
        return new PropagatingAstObserver() {
            @Override
            public void concretePropertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue) {
                observer.propertyChange(observedNode, property, oldValue, newValue);
            }
 
            @Override
            public void concreteListChange(NodeList observedNode, ListChangeType type, int index, Node nodeAddedOrRemoved) {
                observer.listChange(observedNode, type, index, nodeAddedOrRemoved);
            }
 
            @Override
            public void parentChange(Node observedNode, Node previousParent, Node newParent) {
                observer.parentChange(observedNode, previousParent, newParent);
            }
        };
    }
 
    @Override
    public final void propertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue) {
        considerRemoving(oldValue);
        considerAdding(newValue);
        concretePropertyChange(observedNode, property, oldValue, newValue);
    }
 
    @Override
    public final void listChange(NodeList observedNode, ListChangeType type, int index, Node nodeAddedOrRemoved) {
        if (type == ListChangeType.REMOVAL) {
            considerRemoving(nodeAddedOrRemoved);
        } else if (type == ListChangeType.ADDITION) {
            considerAdding(nodeAddedOrRemoved);
        }
        concreteListChange(observedNode, type, index, nodeAddedOrRemoved);
    }
 
    public void concretePropertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue) {
        // do nothing
    }
 
    public void concreteListChange(NodeList observedNode, ListChangeType type, int index, Node nodeAddedOrRemoved) {
        // do nothing
    }
 
    @Override
    public void parentChange(Node observedNode, Node previousParent, Node newParent) {
        // do nothing
    }
 
    private void considerRemoving(Object element) {
        if (element instanceof Observable) {
            if (((Observable) element).isRegistered(this)) {
                ((Observable) element).unregister(this);
            }
        }
    }
 
    private void considerAdding(Object element) {
        if (element instanceof Node) {
            ((Node) element).registerForSubtree(this);
        } else if (element instanceof Observable) {
            ((Observable) element).register(this);
        }
    }
 
}

观察员在行动

让我们看看这在实践中如何工作：

// write some code and parse it
String code = "class A { int f; void foo(int p) { return 'z'; }}";
CompilationUnit cu = JavaParser.parse(code);
 
// set up our observer
List changes = new ArrayList<>();
AstObserver observer = new AstObserverAdapter() {
    @Override
    public void propertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue) {
        changes.add(String.format("%s.%s changed from %s to %s", observedNode.getClass().getSimpleName(), property.name().toLowerCase(), oldValue, newValue));
    }
};
cu.getClassByName("A").register(observer, /* Here we could use different modes */);
 
// Doing some changes
cu.getClassByName("A").setName("MyCoolClass");
cu.getClassByName("MyCoolClass").getFieldByName("f").setElementType(new PrimitiveType(PrimitiveType.Primitive.Boolean));
cu.getClassByName("MyCoolClass").getMethodsByName("foo").get(0).getParamByName("p").setName("myParam");
// Here we are adding a new field and immediately changing it
cu.getClassByName("MyCoolClass").addField("int", "bar").getVariables().get(0).setInit("0");
 
// If we registered our observer with mode JUST_THIS_NODE
assertEquals(Arrays.asList("ClassOrInterfaceDeclaration.name changed from A to MyCoolClass"), changes);
 
// If we registered our observer with mode THIS_NODE_AND_EXISTING_DESCENDANTS
assertEquals(Arrays.asList("ClassOrInterfaceDeclaration.name changed from A to MyCoolClass",
        "FieldDeclaration.element_type changed from int to boolean",
        "VariableDeclaratorId.name changed from p to myParam"), changes);
 
// If we registered our observer with mode SELF_PROPAGATING
assertEquals(Arrays.asList("ClassOrInterfaceDeclaration.name changed from A to MyCoolClass",
        "FieldDeclaration.element_type changed from int to boolean",
        "VariableDeclaratorId.name changed from p to myParam",
        "FieldDeclaration.modifiers changed from [] to []",
        "FieldDeclaration.element_type changed from empty to int",
        "VariableDeclaratorId.array_bracket_pairs_after_id changed from com.github.javaparser.ast.NodeList@1 to com.github.javaparser.ast.NodeList@1",
        "VariableDeclarator.init changed from null to 0"), changes);

结论

我对这个新功能感到非常兴奋，因为我认为它使JavaParser可以完成更多很酷的事情。 我认为我们作为提交者的工作是使其他人能够做我们目前未预见的事情。 我们应该只是充当推动者，然后躲开。

我真的很好奇，看看人们会如何发展。 顺便说一句，您知道您想让我们知道的任何使用JavaParser的项目吗？ 在GitHub上发表评论或发表问题，我们期待您的来信！

翻译自: https://www.javacodegeeks.com/2016/11/observers-ast-nodes-javaparser.html