Add Kernel AST nodes for Vector and Closure primitives in VM

runtime/vm/kernel.h

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_KERNEL_H_
 #define RUNTIME_VM_KERNEL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/token_position.h"
 
 
 #define KERNEL_NODES_DO(M)                                                     \
   M(Name)                                                                      \
   M(DartType)                                                                  \
   M(InvalidType)                                                               \
   M(DynamicType)                                                               \
   M(VoidType)                                                                  \
   M(InterfaceType)                                                             \
   M(FunctionType)                                                              \
-  M(TypeParameterType)
+  M(TypeParameterType)                                                         \
+  M(VectorType)
 
 #define KERNEL_TREE_NODES_DO(M)                                                \
   M(Library)                                                                   \
   M(Class)                                                                     \
   M(NormalClass)                                                               \
   M(MixinClass)                                                                \
   M(Member)                                                                    \
   M(Field)                                                                     \
   M(Constructor)                                                               \
   M(Procedure)                                                                 \
@@ skipping 37 matching lines @@
   M(TypeLiteral)                                                               \
   M(ThisExpression)                                                            \
   M(Rethrow)                                                                   \
   M(Throw)                                                                     \
   M(ListLiteral)                                                               \
   M(MapLiteral)                                                                \
   M(MapEntry)                                                                  \
   M(AwaitExpression)                                                           \
   M(FunctionExpression)                                                        \
   M(Let)                                                                       \
+  M(VectorCreation)                                                            \
+  M(VectorGet)                                                                 \
+  M(VectorSet)                                                                 \
+  M(VectorCopy)                                                                \
+  M(ClosureCreation)                                                           \
   M(Statement)                                                                 \
   M(InvalidStatement)                                                          \
   M(ExpressionStatement)                                                       \
   M(Block)                                                                     \
   M(EmptyStatement)                                                            \
   M(AssertStatement)                                                           \
   M(LabeledStatement)                                                          \
   M(BreakStatement)                                                            \
   M(WhileStatement)                                                            \
   M(DoStatement)                                                               \
@@ skipping 1829 matching lines @@
 
   Child<VariableDeclaration> variable_;
   Child<Expression> body_;
   TokenPosition position_;
   TokenPosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(Let);
 };
 
 
+class VectorCreation : public Expression {
+ public:
+  static VectorCreation* ReadFrom(Reader* reader);
+
+  virtual ~VectorCreation();
+
+  DEFINE_CASTING_OPERATIONS(VectorCreation);
+
+  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
+  virtual void VisitChildren(Visitor* visitor);
+
+  int64_t value() { return value_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
+
+ private:
+  VectorCreation()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
+
+  int64_t value_;

[Kevin Millikin (Google), 2017/04/04 11:29:33]

Use intptr_t, here and elsewhere.

[Dmitry Stefantsov, 2017/04/04 12:51:13]

Done.

+  TokenPosition position_;

[Kevin Millikin (Google), 2017/04/04 11:29:34]

This does not need a token position or an end token position, does it?

[Dmitry Stefantsov, 2017/04/04 12:51:13]

No, I guess not. Thanks! Done.

+  TokenPosition end_position_;
+
+  DISALLOW_COPY_AND_ASSIGN(VectorCreation);
+};
+
+
+class VectorGet : public Expression {
+ public:
+  static VectorGet* ReadFrom(Reader* reader);
+
+  virtual ~VectorGet();
+
+  DEFINE_CASTING_OPERATIONS(VectorGet);
+
+  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
+  virtual void VisitChildren(Visitor* visitor);
+
+  Expression* vector_expression() { return vector_expression_; }
+  int64_t index() { return index_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
+
+ private:
+  VectorGet()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
+
+  Child<Expression> vector_expression_;

[Kevin Millikin (Google), 2017/04/04 11:29:33]

Is it the case that this is always a VariableGet, because contexts are always
named?  We might want to specialize for that case by changing this to
Ref<VariableDeclaration> and similarly below.

[Dmitry Stefantsov, 2017/04/04 12:51:13]

Actually, it's not always VariableGet. In case of a parent context it's
retrieved from 0th position of its child context, so 'context[0]' may also be a
vector expression.

+  int64_t index_;

[Kevin Millikin (Google), 2017/04/04 11:29:34]

intptr_t

[Dmitry Stefantsov, 2017/04/04 12:51:13]

Done.

+  TokenPosition position_;

[Kevin Millikin (Google), 2017/04/04 11:29:34]

We don't need these token positions.

[Dmitry Stefantsov, 2017/04/04 12:51:13]

I guess we may want these, because they replace variable reads. But I guess it's
ok to remove them now.

+  TokenPosition end_position_;
+
+  DISALLOW_COPY_AND_ASSIGN(VectorGet);
+};
+
+
+class VectorSet : public Expression {
+ public:
+  static VectorSet* ReadFrom(Reader* reader);
+
+  virtual ~VectorSet();
+
+  DEFINE_CASTING_OPERATIONS(VectorSet);
+
+  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
+  virtual void VisitChildren(Visitor* visitor);
+
+  Expression* vector_expression() { return vector_expression_; }
+  int64_t index() { return index_; }
+  Expression* value() { return value_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
+
+ private:
+  VectorSet()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
+
+  Child<Expression> vector_expression_;
+  int64_t index_;

[Kevin Millikin (Google), 2017/04/04 11:29:33]

intptr_t

[Dmitry Stefantsov, 2017/04/04 12:51:13]

Done.

+  Child<Expression> value_;
+  TokenPosition position_;

[Kevin Millikin (Google), 2017/04/04 11:29:34]

I guess this will need a position and possibly two, but they have to come from
the binary file.  I'd just leave them out for now since we don't know exactly
what they'll be.

[Dmitry Stefantsov, 2017/04/04 12:51:13]

Agree. Done.

+  TokenPosition end_position_;
+
+  DISALLOW_COPY_AND_ASSIGN(VectorSet);
+};
+
+
+class VectorCopy : public Expression {
+ public:
+  static VectorCopy* ReadFrom(Reader* reader);
+
+  virtual ~VectorCopy();
+
+  DEFINE_CASTING_OPERATIONS(VectorCopy);
+
+  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
+  virtual void VisitChildren(Visitor* visitor);
+
+  Expression* vector_expression() { return vector_expression_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
+
+ private:
+  VectorCopy()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
+
+  Child<Expression> vector_expression_;
+  TokenPosition position_;

[Kevin Millikin (Google), 2017/04/04 11:29:34]

We shouldn't need these positions.

[Dmitry Stefantsov, 2017/04/04 12:51:13]

Agree. Done.

+  TokenPosition end_position_;
+
+  DISALLOW_COPY_AND_ASSIGN(VectorCopy);
+};
+
+
+class ClosureCreation : public Expression {
+ public:
+  static ClosureCreation* ReadFrom(Reader* reader);
+
+  virtual ~ClosureCreation();
+
+  DEFINE_CASTING_OPERATIONS(ClosureCreation);
+
+  virtual void AcceptExpressionVisitor(ExpressionVisitor* visitor);
+  virtual void VisitChildren(Visitor* visitor);
+
+  CanonicalName* top_level_function_reference() {

[Kevin Millikin (Google), 2017/04/04 11:29:33]

For consistency, we don't usually put _reference in the name of this getter.

I don't think it's important that it's a top level function, it seems sort of
incidental.  I'd probably choose a name like closed_function() or
static_function().

[Dmitry Stefantsov, 2017/04/04 12:51:13]

Somehow I've missed this convention. Thanks! Fixed.

+    return top_level_function_reference_;
+  }
+  Expression* context_vector() { return context_vector_; }
+  FunctionType* function_type() { return function_type_; }
+  TokenPosition position() { return position_; }
+  TokenPosition end_position() { return end_position_; }
+
+ private:
+  ClosureCreation()
+      : position_(TokenPosition::kNoSource),
+        end_position_(TokenPosition::kNoSource) {}
+
+  Ref<CanonicalName> top_level_function_reference_;  // Procedure.
+  Child<Expression> context_vector_;
+  Child<FunctionType> function_type_;
+  TokenPosition position_;

[Kevin Millikin (Google), 2017/04/04 11:29:34]

I don't think we need these positions.

[Dmitry Stefantsov, 2017/04/04 12:51:13]

Done.

+  TokenPosition end_position_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClosureCreation);
+};
+
+
 class Statement : public TreeNode {
  public:
   static Statement* ReadFrom(Reader* reader);
 
   virtual ~Statement();
 
   DEFINE_CASTING_OPERATIONS(Statement);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void AcceptStatementVisitor(StatementVisitor* visitor) = 0;
@@ skipping 755 matching lines @@
 
  private:
   TypeParameterType() {}
 
   Ref<TypeParameter> parameter_;
 
   DISALLOW_COPY_AND_ASSIGN(TypeParameterType);
 };
 
 
+class VectorType : public DartType {
+ public:
+  static VectorType* ReadFrom(Reader* reader);
+
+  virtual ~VectorType();
+
+  DEFINE_CASTING_OPERATIONS(VectorType);
+
+  virtual void AcceptDartTypeVisitor(DartTypeVisitor* visitor);
+  virtual void VisitChildren(Visitor* visitor);
+
+ private:
+  VectorType() {}
+
+  DISALLOW_COPY_AND_ASSIGN(VectorType);
+};
+
+
 class TypeParameter : public TreeNode {
  public:
   TypeParameter* ReadFrom(Reader* reader);
 
   virtual ~TypeParameter();
 
   DEFINE_CASTING_OPERATIONS(TypeParameter);
 
   virtual void AcceptTreeVisitor(TreeVisitor* visitor);
   virtual void VisitChildren(Visitor* visitor);
@@ skipping 153 matching lines @@
   virtual void VisitDoubleLiteral(DoubleLiteral* node) {
     VisitDefaultBasicLiteral(node);
   }
   virtual void VisitBoolLiteral(BoolLiteral* node) {
     VisitDefaultBasicLiteral(node);
   }
   virtual void VisitNullLiteral(NullLiteral* node) {
     VisitDefaultBasicLiteral(node);
   }
   virtual void VisitLet(Let* node) { VisitDefaultExpression(node); }
+  virtual void VisitVectorCreation(VectorCreation* node) {
+    VisitDefaultExpression(node);
+  }
+  virtual void VisitVectorGet(VectorGet* node) { VisitDefaultExpression(node); }
+  virtual void VisitVectorSet(VectorSet* node) { VisitDefaultExpression(node); }
+  virtual void VisitVectorCopy(VectorCopy* node) {
+    VisitDefaultExpression(node);
+  }
+  virtual void VisitClosureCreation(ClosureCreation* node) {
+    VisitDefaultExpression(node);
+  }
 };
 
 
 class StatementVisitor {
  public:
   virtual ~StatementVisitor() {}
 
   virtual void VisitDefaultStatement(Statement* node) = 0;
   virtual void VisitInvalidStatement(InvalidStatement* node) {
     VisitDefaultStatement(node);
@@ skipping 112 matching lines @@
   virtual void VisitVoidType(VoidType* node) { VisitDefaultDartType(node); }
   virtual void VisitInterfaceType(InterfaceType* node) {
     VisitDefaultDartType(node);
   }
   virtual void VisitFunctionType(FunctionType* node) {
     VisitDefaultDartType(node);
   }
   virtual void VisitTypeParameterType(TypeParameterType* node) {
     VisitDefaultDartType(node);
   }
+  virtual void VisitVectorType(VectorType* node) { VisitDefaultDartType(node); }
 };
 
 
 class TreeVisitor : public ExpressionVisitor,
                     public StatementVisitor,
                     public MemberVisitor,
                     public ClassVisitor,
                     public InitializerVisitor {
  public:
   virtual ~TreeVisitor() {}
@@ skipping 125 matching lines @@
 
 ParsedFunction* ParseStaticFieldInitializer(Zone* zone,
                                             const dart::Field& field);
 
 }  // namespace kernel
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length);
 
 
-
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_H_