[kernel] Stream everything. Replace .kernel_function with .kernel_offset

runtime/vm/kernel_binary_flowgraph.h

 // Copyright (c) 2017, 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_BINARY_FLOWGRAPH_H_
 #define RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include <map>
 
 #include "vm/kernel.h"
 #include "vm/kernel_binary.h"
 #include "vm/kernel_to_il.h"
 #include "vm/object.h"
 
 namespace dart {
 namespace kernel {
 
 class StreamingDartTypeTranslator {
  public:
   StreamingDartTypeTranslator(StreamingFlowGraphBuilder* builder,
                               bool finalize = false);
 
   // Can return a malformed type.
   AbstractType& BuildType();
+  // Can return a malformed type.
+  AbstractType& BuildTypeWithoutFinalization();
   // Is guaranteed to be not malformed.
   AbstractType& BuildVariableType();
 
   // Will return `TypeArguments::null()` in case any of the arguments are
   // malformed.
   const TypeArguments& BuildTypeArguments(intptr_t length);
 
   // Will return `TypeArguments::null()` in case any of the arguments are
   // malformed.
   const TypeArguments& BuildInstantiatedTypeArguments(
@@ skipping 57 matching lines @@
                         intptr_t kernel_offset,
                         const uint8_t* buffer,
                         intptr_t buffer_length);
 
   virtual ~StreamingScopeBuilder();
 
   ScopeBuildingResult* BuildScopes();
 
  private:
   void VisitField();
-  void ReadFieldUntilAnnotation(TokenPosition* position,
-                                TokenPosition* end_position,
-                                word* flags,
-                                intptr_t* parent_offset);
 
-  /**
-   * Will read until the function node; as this is optional, will return the tag
-   * (i.e. either kSomething or kNothing).
-   */
-  Tag ReadProcedureUntilFunctionNode(word* kind, intptr_t* parent_offset);
-  void GetTypeParameterInfoForPossibleProcedure(
-      intptr_t outermost_kernel_offset,
-      bool* member_is_procedure,
-      bool* is_factory_procedure,
-      intptr_t* member_type_parameters,
-      intptr_t* member_type_parameters_offset_start);
   void VisitProcedure();
 
-  /**
-   * Will return binary offset of parent class.
-   */
-  intptr_t ReadConstructorUntilFunctionNode();
   void VisitConstructor();
 
-  void ReadClassUntilTypeParameters();
-  void ReadClassUntilFields();
-
-  void ReadFunctionNodeUntilTypeParameters(word* async_marker,
-                                           word* dart_async_marker);
   void VisitFunctionNode();
-
-  void DiscoverEnclosingElements(Zone* zone,
-                                 const Function& function,
-                                 Function* outermost_function,
-                                 intptr_t* outermost_kernel_offset,
-                                 intptr_t* parent_class_offset);
-  intptr_t GetParentOffset(intptr_t offset);
-  void GetTypeParameterInfoForClass(intptr_t class_offset,
-                                    intptr_t* type_paremeter_counts,
-                                    intptr_t* type_paremeter_offset);
   void VisitNode();
   void VisitInitializer();
   void VisitExpression();
   void VisitStatement();
   void VisitArguments();
   void VisitVariableDeclaration();
   void VisitDartType();
   void VisitInterfaceType(bool simple);
   void VisitFunctionType(bool simple);
   void VisitTypeParameterType();
@@ skipping 20 matching lines @@
 
   void AddExceptionVariable(GrowableArray<LocalVariable*>* variables,
                             const char* prefix,
                             intptr_t nesting_depth);
 
   void AddTryVariables();
   void AddCatchVariables();
   void AddIteratorVariable();
   void AddSwitchVariable();
 
-  StringIndex GetNameFromVariableDeclaration(intptr_t kernel_offset);
-
   // Record an assignment or reference to a variable.  If the occurrence is
   // in a nested function, ensure that the variable is handled properly as a
   // captured variable.
   void LookupVariable(intptr_t declaration_binary_offest);
 
   const dart::String& GenerateName(const char* prefix, intptr_t suffix);
 
   void HandleSpecialLoad(LocalVariable** variable, const dart::String& symbol);
   void LookupCapturedVariableByName(LocalVariable** variable,
                                     const dart::String& name);
@@ skipping 33 matching lines @@
 
   bool needs_expr_temp_;
   TokenPosition first_body_token_position_;
 
   StreamingFlowGraphBuilder* builder_;
   StreamingDartTypeTranslator type_translator_;
 
   word unused_word;
   intptr_t unused_intptr;
   TokenPosition unused_tokenposition;
+  NameIndex unused_nameindex;
 };
 
 
+// There are several cases when we are compiling constant expressions:
+//
+//   * constant field initializers:
+//      const FieldName = <expr>;
+//
+//   * constant expressions:
+//      const [<expr>, ...]
+//      const {<expr> : <expr>, ...}
+//      const Constructor(<expr>, ...)
+//
+//   * constant default parameters:
+//      f(a, [b = <expr>])
+//      f(a, {b: <expr>})
+//
+//   * constant values to compare in a [SwitchCase]
+//      case <expr>:
+//
+// In all cases `<expr>` must be recursively evaluated and canonicalized at
+// compile-time.
 class StreamingConstantEvaluator {
  public:
   explicit StreamingConstantEvaluator(StreamingFlowGraphBuilder* builder);
 
   virtual ~StreamingConstantEvaluator() {}
 
   Instance& EvaluateExpression(intptr_t offset, bool reset_position = true);
   Instance& EvaluateListLiteral(intptr_t offset, bool reset_position = true);
   Instance& EvaluateMapLiteral(intptr_t offset, bool reset_position = true);
   Instance& EvaluateConstructorInvocation(intptr_t offset,
@@ skipping 69 matching lines @@
   StreamingFlowGraphBuilder(FlowGraphBuilder* flow_graph_builder,
                             const uint8_t* buffer,
                             intptr_t buffer_length)
       : flow_graph_builder_(flow_graph_builder),
         translation_helper_(flow_graph_builder->translation_helper_),
         zone_(flow_graph_builder->zone_),
         reader_(new Reader(buffer, buffer_length)),
         constant_evaluator_(this),
         type_translator_(this, /* finalize= */ true) {}
 
-  ~StreamingFlowGraphBuilder() { delete reader_; }
-
-  Fragment BuildExpressionAt(intptr_t kernel_offset);
-  Fragment BuildStatementAt(intptr_t kernel_offset);
-
- private:
   StreamingFlowGraphBuilder(TranslationHelper* translation_helper,
                             Zone* zone,
                             const uint8_t* buffer,
                             intptr_t buffer_length)
       : flow_graph_builder_(NULL),
         translation_helper_(*translation_helper),
         zone_(zone),
         reader_(new Reader(buffer, buffer_length)),
         constant_evaluator_(this),
         type_translator_(this, /* finalize= */ true) {}
 
+  ~StreamingFlowGraphBuilder() { delete reader_; }
+
+  FlowGraph* BuildGraph(intptr_t kernel_offset);
+
+  Fragment BuildStatementAt(intptr_t kernel_offset);
+  RawObject* BuildParameterDescriptor(intptr_t kernel_offset);
+  RawObject* EvaluateMetadata(intptr_t kernel_offset);
+
+ private:
+  void DiscoverEnclosingElements(Zone* zone,
+                                 const Function& function,
+                                 Function* outermost_function,
+                                 intptr_t* outermost_kernel_offset,
+                                 intptr_t* parent_class_offset);
+  intptr_t GetParentOffset(intptr_t offset);
+  void GetTypeParameterInfoForClass(intptr_t class_offset,
+                                    intptr_t* type_paremeter_counts,
+                                    intptr_t* type_paremeter_offset);
+  void ReadClassUntilFields();
+  void ReadClassUntilTypeParameters();
+  /**
+   * Will return binary offset of parent class.
+   */
+  intptr_t ReadConstructorUntilFunctionNode();
+  /**
+   * Will read until the function node; as this is optional, will return the tag
+   * (i.e. either kSomething or kNothing).
+   */
+  Tag ReadProcedureUntilFunctionNode(word* kind, intptr_t* parent_offset);
+
+  void ReadFieldUntilAnnotation(NameIndex* canonical_name,
+                                TokenPosition* position,
+                                TokenPosition* end_position,
+                                word* flags,
+                                intptr_t* parent_offset);
+  void GetTypeParameterInfoForPossibleProcedure(
+      intptr_t outermost_kernel_offset,
+      bool* member_is_procedure,
+      bool* is_factory_procedure,
+      intptr_t* member_type_parameters,
+      intptr_t* member_type_parameters_offset_start);
+  void ReadFunctionNodeUntilTypeParameters(TokenPosition* position,
+                                           TokenPosition* end_position,
+                                           word* async_marker,
+                                           word* dart_async_marker);
+  /**
+   * Will return kernel offset for parent class if reading a constructor.
+   * Will otherwise return -1.
+   */
+  intptr_t ReadUntilFunctionNode();
+  StringIndex GetNameFromVariableDeclaration(intptr_t kernel_offset);
+
+  FlowGraph* BuildGraphOfStaticFieldInitializer();
+  FlowGraph* BuildGraphOfFieldAccessor(LocalVariable* setter_value);
+  void SetupDefaultParameterValues();
+  Fragment BuildFieldInitializer(NameIndex canonical_name);
+  Fragment BuildInitializers(intptr_t constructor_class_parent_offset);
+  FlowGraph* BuildGraphOfImplicitClosureFunction(const Function& function);
+  FlowGraph* BuildGraphOfFunction(
+      bool is_in_builtin_library_toplevel,
+      intptr_t constructor_class_parent_offset = -1);
+  Fragment BuildGetMainClosure();
+
   Fragment BuildExpression(TokenPosition* position = NULL);
   Fragment BuildStatement();
 
   intptr_t ReaderOffset();
   void SetOffset(intptr_t offset);
   void SkipBytes(intptr_t skip);
   bool ReadBool();
   uint8_t ReadByte();
   uint32_t ReadUInt();
   uint32_t PeekUInt();
@@ skipping 34 matching lines @@
   void catch_depth_dec();
   void try_depth_inc();
   void try_depth_dec();
   intptr_t CurrentTryIndex();
   intptr_t AllocateTryIndex();
   LocalVariable* CurrentException();
   LocalVariable* CurrentStackTrace();
   CatchBlock* catch_block();
   ActiveClass* active_class();
   ScopeBuildingResult* scopes();
+  void set_scopes(ScopeBuildingResult* scope);
   ParsedFunction* parsed_function();
   TryFinallyBlock* try_finally_block();
   SwitchBlock* switch_block();
   BreakableBlock* breakable_block();
   GrowableArray<YieldContinuation>& yield_continuations();
   Value* stack();
   Value* Pop();
 
   Tag PeekArgumentsFirstPositionalTag();
   const TypeArguments& PeekArgumentsInstantiatedType(const dart::Class& klass);
@@ skipping 118 matching lines @@
   Fragment BuildStringConcatenation(TokenPosition* position);
   Fragment BuildIsExpression(TokenPosition* position);
   Fragment BuildAsExpression(TokenPosition* position);
   Fragment BuildSymbolLiteral(TokenPosition* position);
   Fragment BuildTypeLiteral(TokenPosition* position);
   Fragment BuildThisExpression(TokenPosition* position);
   Fragment BuildRethrow(TokenPosition* position);
   Fragment BuildThrow(TokenPosition* position);
   Fragment BuildListLiteral(bool is_const, TokenPosition* position);
   Fragment BuildMapLiteral(bool is_const, TokenPosition* position);
+  Fragment BuildFunctionExpression();
   Fragment BuildLet(TokenPosition* position);
   Fragment BuildBigIntLiteral(TokenPosition* position);
   Fragment BuildStringLiteral(TokenPosition* position);
   Fragment BuildIntLiteral(uint8_t payload, TokenPosition* position);
   Fragment BuildIntLiteral(bool is_negative, TokenPosition* position);
   Fragment BuildDoubleLiteral(TokenPosition* position);
   Fragment BuildBoolLiteral(bool value, TokenPosition* position);
   Fragment BuildNullLiteral(TokenPosition* position);
 
   Fragment BuildInvalidStatement();
   Fragment BuildExpressionStatement();
   Fragment BuildBlock();
   Fragment BuildEmptyStatement();
   Fragment BuildAssertStatement();
   Fragment BuildLabeledStatement();
   Fragment BuildBreakStatement();
   Fragment BuildWhileStatement();
   Fragment BuildDoStatement();
   Fragment BuildForStatement();
   Fragment BuildForInStatement(bool async);
   Fragment BuildSwitchStatement();
   Fragment BuildContinueSwitchStatement();
   Fragment BuildIfStatement();
   Fragment BuildReturnStatement();
   Fragment BuildTryCatch();
   Fragment BuildTryFinally();
   Fragment BuildYieldStatement();
   Fragment BuildVariableDeclaration();
+  Fragment BuildFunctionDeclaration();
+  Fragment BuildFunctionNode(intptr_t parent_kernel_offset,
+                             TokenPosition parent_position,
+                             bool declaration,
+                             intptr_t variable_offeset);
+  void SetupFunctionParameters(const dart::Class& klass,
+                               const dart::Function& function,
+                               bool is_method,
+                               bool is_closure);
 
   FlowGraphBuilder* flow_graph_builder_;
   TranslationHelper& translation_helper_;
   Zone* zone_;
   Reader* reader_;
   StreamingConstantEvaluator constant_evaluator_;
   StreamingDartTypeTranslator type_translator_;
 
+  word unused_word;
+  intptr_t unused_intptr;
+  TokenPosition unused_tokenposition;
+  NameIndex unused_nameindex;
+
   friend class StreamingConstantEvaluator;
   friend class StreamingDartTypeTranslator;
   friend class StreamingScopeBuilder;
 };
 
 // A helper class that saves the current reader position, goes to another reader
 // position, and upon destruction, resets to the original reader position.
 class AlternativeReadingScope {
  public:
   AlternativeReadingScope(Reader* reader, intptr_t new_position)
       : reader_(reader), saved_offset_(reader_->offset()) {
     reader_->set_offset(new_position);
   }
 
   explicit AlternativeReadingScope(Reader* reader)
       : reader_(reader), saved_offset_(reader_->offset()) {}
 
   ~AlternativeReadingScope() { reader_->set_offset(saved_offset_); }
 
  private:
   Reader* reader_;
   intptr_t saved_offset_;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_BINARY_FLOWGRAPH_H_