Merge branch 'master' of github.com:microsoft/checkedc-clang

Author: mattmccutchen-cci

.gitattributes

@@ -23,29 +23,32 @@
 
 namespace clang {
   using Result = Lexicographic::Result;
+  class OperatorNode;
 
   class Node {
   public:
-    enum class NodeKind { BinaryNode, LeafExprNode };
+    enum class NodeKind { OperatorNode, LeafExprNode };
 
     NodeKind Kind;
-    Node *Parent;
+    OperatorNode *Parent;
 
-    Node(NodeKind Kind, Node *Parent) :
+    Node(NodeKind Kind, OperatorNode *Parent) :
       Kind(Kind), Parent(Parent) {}
   };
 
-  class BinaryNode : public Node {
+  class OperatorNode : public Node {
   public:
     BinaryOperator::Opcode Opc;
+    // Note: An OperatorNode has a list of children because the preorder AST is
+    // an n-ary tree.
     llvm::SmallVector<Node *, 2> Children;
 
-    BinaryNode(BinaryOperator::Opcode Opc, Node *Parent) :
-      Node(NodeKind::BinaryNode, Parent),
+    OperatorNode(BinaryOperator::Opcode Opc, OperatorNode *Parent) :
+      Node(NodeKind::OperatorNode, Parent),
       Opc(Opc) {}
 
     static bool classof(const Node *N) {
-      return N->Kind == NodeKind::BinaryNode;
+      return N->Kind == NodeKind::OperatorNode;
     }
 
     // Is the operator commutative and associative?
@@ -58,7 +61,7 @@ namespace clang {
   public:
     Expr *E;
 
-    LeafExprNode(Expr *E, Node *Parent) :
+    LeafExprNode(Expr *E, OperatorNode *Parent) :
       Node(NodeKind::LeafExprNode, Parent),
       E(E) {}
 
@@ -81,27 +84,32 @@ namespace clang {
     // Create a PreorderAST for the expression E.
     // @param[in] E is the sub expression to be added to a new node.
     // @param[in] Parent is the parent of the new node.
-    void Create(Expr *E, Node *Parent = nullptr);
+    void Create(Expr *E, OperatorNode *Parent = nullptr);
 
     // Add a new node to the AST.
     // @param[in] Node is the current node to be added.
     // @param[in] Parent is the parent of the node to be added.
-    void AddNode(Node *N, Node *Parent);
+    void AddNode(Node *N, OperatorNode *Parent);
 
-    // Move the children (if any) of node N to its parent and then remove N.
-    // @param[in] N is the current node.
-    // @param[in] P is the parent of the node to be removed. P should be a
-    // BinaryNode.
-    void RemoveNode(Node *N, Node *P);
+    // Coalesce the OperatorNode O with its parent. This involves moving the
+    // children (if any) of node O to its parent and then removing O.
+    // @param[in] O is the current node. O should be a OperatorNode.
+    void CoalesceNode(OperatorNode *O);
 
-    // Recursively coalesce binary nodes having the same commutative and
+    // Determines if a OperatorNode could be coalesced into its parent.
+    // @param[in] O is the current node. O should be a OperatorNode.
+    // @return Return true if O can be coalesced into its parent, false
+    // otherwise.
+    bool CanCoalesceNode(OperatorNode *O);
+
+    // Recursively coalesce OperatoreNodes having the same commutative and
     // associative operator.
     // @param[in] N is current node of the AST. Initial value is Root.
     // @param[in] Changed indicates whether a node was coalesced. We need this
     // to control when to stop recursive coalescing.
     void Coalesce(Node *N, bool &Changed);
 
-    // Sort the children expressions in a binary node of the AST.
+    // Sort the children expressions in a OperatorNode of the AST.
     // @param[in] N is current node of the AST. Initial value is Root.
     void Sort(Node *N);