[Interpreter] Add CreateClosure to BytecodeGraphBuilder.

test/unittests/compiler/node-test-utils.cc

 // Copyright 2014 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.
 
 #include "test/unittests/compiler/node-test-utils.h"
 
 #include <vector>
 
 #include "src/assembler.h"
 #include "src/compiler/common-operator.h"
@@ skipping 1840 matching lines @@
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const std::vector<Matcher<Node*>> value_matchers_;
   const Matcher<Node*> effect_matcher_;
   const Matcher<Node*> control_matcher_;
 };
 
+
+class CreateClosureParametersMatcher final
+    : public MatcherInterface<CreateClosureParameters*> {
+ public:
+  explicit CreateClosureParametersMatcher(CreateClosureParameters* parameters)
+      : parameters_(parameters) {}
+
+  void DescribeTo(::std::ostream* os) const final {
+    *os << "is a CreateClosureParameters instance";
+  }
+
+  bool MatchAndExplain(CreateClosureParameters* parameters,
+                       MatchResultListener* listener) const override {
+    if (parameters == NULL) {
+      *listener << "which is NULL";
+      return false;
+    }
+    if (*parameters->shared_info() != *parameters_->shared_info()) {
+      *listener << "whose shared function info is "
+                << *parameters->shared_info() << " but should have been "
+                << *parameters_->shared_info();
+      return false;
+    }
+    if (parameters->pretenure() != parameters_->pretenure()) {
+      *listener << "whose tenured flag is " << parameters->pretenure()
+                << " but should have been " << parameters_->pretenure();
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  CreateClosureParameters* parameters_;
+};
+
+
+class IsCreateClosureMatcher final : public NodeMatcher {
+ public:
+  IsCreateClosureMatcher(
+      const Matcher<CreateClosureParameters*>& parameters_matcher,
+      const Matcher<Node*>& effect_matcher,
+      const Matcher<Node*>& control_matcher)
+      : NodeMatcher(IrOpcode::Value::kJSCreateClosure),
+        parameters_matcher_(parameters_matcher),
+        effect_matcher_(effect_matcher),
+        control_matcher_(control_matcher) {}
+
+  void DescribeTo(std::ostream* os) const final {
+    NodeMatcher::DescribeTo(os);
+    *os << " whose value (";
+    parameters_matcher_.DescribeTo(os);
+    *os << "), effect (";
+    effect_matcher_.DescribeTo(os);
+    *os << ") and control (";
+    control_matcher_.DescribeTo(os);
+    *os << ")";
+  }
+
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
+    if (!NodeMatcher::MatchAndExplain(node, listener)) {
+      return false;
+    }
+    CreateClosureParameters parameters =
+        OpParameter<CreateClosureParameters>(node);
+    return (PrintMatchAndExplain(&parameters, "value", parameters_matcher_,

[Michael Starzinger, 2015/11/23 11:18:38]

Instead of going through extra lengths of making the "CreateClosureParameters"
comparable, can we instead just extract it from the node and compare the values
within? This would make the entire CreateClosureParametersMatcher obsolete. This
is similar to what we do in other matcher, IsJSLoadNamedMatcher for example.

[oth, 2015/11/24 12:29:36]

Done.

+                                 listener) &&
+            PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
+                                 effect_matcher_, listener) &&
+            PrintMatchAndExplain(NodeProperties::GetControlInput(node),
+                                 "control", control_matcher_, listener));
+  }
+
+ private:
+  const Matcher<CreateClosureParameters*> parameters_matcher_;
+  const Matcher<Node*> effect_matcher_;
+  const Matcher<Node*> control_matcher_;
+};
+
 }  // namespace
 
 
 Matcher<Node*> IsDead() {
   return MakeMatcher(new NodeMatcher(IrOpcode::kDead));
 }
 
 
 Matcher<Node*> IsEnd(const Matcher<Node*>& control0_matcher) {
   return MakeMatcher(new IsControl1Matcher(IrOpcode::kEnd, control0_matcher));
@@ skipping 657 matching lines @@
 
 Matcher<Node*> IsJSCallRuntime(std::vector<Matcher<Node*>> value_matchers,
                                const Matcher<Node*>& effect_matcher,
                                const Matcher<Node*>& control_matcher) {
   return MakeMatcher(new IsJSCallMatcher(IrOpcode::kJSCallRuntime,
                                          value_matchers, effect_matcher,
                                          control_matcher));
 }
 
 
+Matcher<CreateClosureParameters*> IsCreateClosureParameters(
+    CreateClosureParameters* parameters) {
+  return MakeMatcher(new CreateClosureParametersMatcher(parameters));
+}
+
+
+Matcher<Node*> IsCreateClosure(
+    const Matcher<CreateClosureParameters*>& parameters_matcher,
+    const Matcher<Node*>& effect_matcher,
+    const Matcher<Node*>& control_matcher) {
+  return MakeMatcher(new IsCreateClosureMatcher(
+      parameters_matcher, effect_matcher, control_matcher));
+}
+
+
 #define IS_BINOP_MATCHER(Name)                                            \
   Matcher<Node*> Is##Name(const Matcher<Node*>& lhs_matcher,              \
                           const Matcher<Node*>& rhs_matcher) {            \
     return MakeMatcher(                                                   \
         new IsBinopMatcher(IrOpcode::k##Name, lhs_matcher, rhs_matcher)); \
   }
 IS_BINOP_MATCHER(NumberEqual)
 IS_BINOP_MATCHER(NumberLessThan)
 IS_BINOP_MATCHER(NumberSubtract)
 IS_BINOP_MATCHER(NumberMultiply)
@@ skipping 65 matching lines @@
 IS_UNOP_MATCHER(NumberToUint32)
 IS_UNOP_MATCHER(ObjectIsSmi)
 IS_UNOP_MATCHER(Word32Clz)
 IS_UNOP_MATCHER(JSUnaryNot)
 IS_UNOP_MATCHER(JSTypeOf)
 #undef IS_UNOP_MATCHER
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8