Better typing and type verification

src/compiler/graph.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_COMPILER_GRAPH_H_
 #define V8_COMPILER_GRAPH_H_
 
 #include <map>
 #include <set>
 
@@ skipping 49 matching lines @@
 
   template <class Visitor>
   void VisitNodeUsesFrom(Node* node, Visitor* visitor);
 
   template <class Visitor>
   void VisitNodeUsesFromStart(Visitor* visitor);
 
   template <class Visitor>
   void VisitNodeInputsFromEnd(Visitor* visitor);
 
+  void Decorate(Node* node);
+
   void AddDecorator(GraphDecorator* decorator) {
     decorators_.push_back(decorator);
   }
 
   void RemoveDecorator(GraphDecorator* decorator) {
     DecoratorVector::iterator it =
         std::find(decorators_.begin(), decorators_.end(), decorator);
     DCHECK(it != decorators_.end());
     decorators_.erase(it, it + 1);
   }
 
+  bool is_typed() const { return is_typed_; }

[titzer, 2014/08/28 13:12:31]

Gah, we went through this with the source positions. Please don't make the graph
stateful. That's the whole point of the decorators. Maybe you can have
IsDecoratedWith?

[rossberg, 2014/08/28 15:35:50]

Hm, well, the graph _is_ fundamentally stateful. This is just being honest about
it. :) I could remove the explication in this flag, but it enables more
assertions (which actually were quite helpful so far).
Then verification would check all the wrong thing when you happen to remove a
decorator. Is that desirable?

A more workable option would be to pass typedness as a flag to the verifier.
That's a version I had earlier, but it's more verbose, and as mentioned, you
loose some useful assertions.

But if you prefer, I can change it that way.

[titzer, 2014/10/01 08:30:24]

Just because nodes and edges can be mutated doesn't mean that the Graph
datastructure, which serves as both a node factory and a handle on a couple of
special nodes, should be tasked with carrying around even more state. E.g. we
don't carry around the "level" of the IR of the nodes in the graph (i.e.
simplified versus JS versus machine). You might argue that we should, and you
might be right, even, but the Graph datastructure isn't really the right place
to store it, IMO.

+  void MarkTyped() { is_typed_ = true; }
+
  private:
   typedef std::vector<GraphDecorator*, zone_allocator<GraphDecorator*> >
       DecoratorVector;
   DecoratorVector decorators_;
+  bool is_typed_;
 };
 
 
 class GraphDecorator : public ZoneObject {
  public:
   virtual ~GraphDecorator() {}
   virtual void Decorate(Node* node) = 0;
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_GRAPH_H_