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

runtime/vm/kernel_to_il.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_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
 #include "vm/hash_map.h"
 
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
+#include "vm/kernel.h"
 
 namespace dart {
 namespace kernel {
 
 class StreamingFlowGraphBuilder;
 
 class KernelConstMapKeyEqualsTraits {
  public:
   static const char* Name() { return "KernelConstMapKeyEqualsTraits"; }
   static bool ReportStats() { return false; }
@@ skipping 517 matching lines @@
 
   TranslationHelper& translation_helper_;
   ActiveClass* active_class_;
   TypeParameterScope* type_parameter_scope_;
   Zone* zone_;
   AbstractType& result_;
   bool finalize_;
 };
 
 
+// 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 ConstantEvaluator : public ExpressionVisitor {
+ public:
+  ConstantEvaluator(FlowGraphBuilder* builder,
+                    Zone* zone,
+                    TranslationHelper* h,
+                    DartTypeTranslator* type_translator);
+  virtual ~ConstantEvaluator() {}
+
+  Instance& EvaluateExpression(Expression* node);
+  Object& EvaluateExpressionSafe(Expression* node);
+  Instance& EvaluateConstructorInvocation(ConstructorInvocation* node);
+  Instance& EvaluateListLiteral(ListLiteral* node);
+  Instance& EvaluateMapLiteral(MapLiteral* node);
+
+  virtual void VisitDefaultExpression(Expression* node) { UNREACHABLE(); }
+
+  virtual void VisitBigintLiteral(BigintLiteral* node);
+  virtual void VisitBoolLiteral(BoolLiteral* node);
+  virtual void VisitDoubleLiteral(DoubleLiteral* node);
+  virtual void VisitIntLiteral(IntLiteral* node);
+  virtual void VisitNullLiteral(NullLiteral* node);
+  virtual void VisitStringLiteral(StringLiteral* node);
+  virtual void VisitSymbolLiteral(SymbolLiteral* node);
+  virtual void VisitTypeLiteral(TypeLiteral* node);
+
+  virtual void VisitListLiteral(ListLiteral* node);
+  virtual void VisitMapLiteral(MapLiteral* node);
+
+  virtual void VisitConstructorInvocation(ConstructorInvocation* node);
+  virtual void VisitMethodInvocation(MethodInvocation* node);
+  virtual void VisitStaticGet(StaticGet* node);
+  virtual void VisitVariableGet(VariableGet* node);
+  virtual void VisitLet(Let* node);
+  virtual void VisitStaticInvocation(StaticInvocation* node);
+  virtual void VisitStringConcatenation(StringConcatenation* node);
+  virtual void VisitConditionalExpression(ConditionalExpression* node);
+  virtual void VisitLogicalExpression(LogicalExpression* node);
+  virtual void VisitNot(Not* node);
+  virtual void VisitPropertyGet(PropertyGet* node);
+
+ private:
+  // This will translate type arguments form [kernel_arguments].  If no type
+  // arguments are passed and the [target] is a factory then the null type
+  // argument array will be returned.
+  //
+  // If none of these cases apply, NULL will be returned.
+  const TypeArguments* TranslateTypeArguments(const Function& target,
+                                              dart::Class* target_klass,
+                                              Arguments* kernel_arguments);
+
+  const Object& RunFunction(const Function& function,
+                            Arguments* arguments,
+                            const Instance* receiver = NULL,
+                            const TypeArguments* type_args = NULL);
+
+  const Object& RunFunction(const Function& function,
+                            const Array& arguments,
+                            const Array& names);
+
+  RawObject* EvaluateConstConstructorCall(const dart::Class& type_class,
+                                          const TypeArguments& type_arguments,
+                                          const Function& constructor,
+                                          const Object& argument);
+
+  void AssertBoolInCheckedMode() {
+    if (isolate_->type_checks() && !result_.IsBool()) {
+      translation_helper_.ReportError("Expected boolean expression.");
+    }
+  }
+
+  bool EvaluateBooleanExpression(Expression* expression) {
+    EvaluateExpression(expression);
+    AssertBoolInCheckedMode();
+    return result_.raw() == Bool::True().raw();
+  }
+
+  bool GetCachedConstant(TreeNode* node, Instance* value);
+  void CacheConstantValue(TreeNode* node, const Instance& value);
+
+  FlowGraphBuilder* builder_;
+  Isolate* isolate_;
+  Zone* zone_;
+  TranslationHelper& translation_helper_;
+  DartTypeTranslator& type_translator_;
+
+  Script& script_;
+  Instance& result_;
+};
+
+
 struct FunctionScope {
   intptr_t kernel_offset;
   LocalScope* scope;
 };
 
 
 class ScopeBuildingResult : public ZoneAllocated {
  public:
   ScopeBuildingResult()
       : this_variable(NULL),
@@ skipping 48 matching lines @@
   Instruction* entry;
   intptr_t try_index;
 
   YieldContinuation(Instruction* entry, intptr_t try_index)
       : entry(entry), try_index(try_index) {}
 
   YieldContinuation()
       : entry(NULL), try_index(CatchClauseNode::kInvalidTryIndex) {}
 };
 
-class FlowGraphBuilder {
+class FlowGraphBuilder : public ExpressionVisitor, public StatementVisitor {
  public:
-  FlowGraphBuilder(intptr_t kernel_offset,
+  FlowGraphBuilder(TreeNode* node,
                    ParsedFunction* parsed_function,
                    const ZoneGrowableArray<const ICData*>& ic_data_array,
                    ZoneGrowableArray<intptr_t>* context_level_array,
                    InlineExitCollector* exit_collector,
                    intptr_t osr_id,
                    intptr_t first_block_id = 1);
   virtual ~FlowGraphBuilder();
 
   FlowGraph* BuildGraph();
 
+  virtual void VisitDefaultExpression(Expression* node) { UNREACHABLE(); }
+  virtual void VisitDefaultStatement(Statement* node) { UNREACHABLE(); }
+
+  virtual void VisitInvalidExpression(InvalidExpression* node);
+  virtual void VisitNullLiteral(NullLiteral* node);
+  virtual void VisitBoolLiteral(BoolLiteral* node);
+  virtual void VisitIntLiteral(IntLiteral* node);
+  virtual void VisitBigintLiteral(BigintLiteral* node);
+  virtual void VisitDoubleLiteral(DoubleLiteral* node);
+  virtual void VisitStringLiteral(StringLiteral* node);
+  virtual void VisitSymbolLiteral(SymbolLiteral* node);
+  virtual void VisitTypeLiteral(TypeLiteral* node);
+  virtual void VisitVariableGet(VariableGet* node);
+  virtual void VisitVariableSet(VariableSet* node);
+  virtual void VisitStaticGet(StaticGet* node);
+  virtual void VisitStaticSet(StaticSet* node);
+  virtual void VisitPropertyGet(PropertyGet* node);
+  virtual void VisitPropertySet(PropertySet* node);
+  virtual void VisitDirectPropertyGet(DirectPropertyGet* node);
+  virtual void VisitDirectPropertySet(DirectPropertySet* node);
+  virtual void VisitStaticInvocation(StaticInvocation* node);
+  virtual void VisitMethodInvocation(MethodInvocation* node);
+  virtual void VisitDirectMethodInvocation(DirectMethodInvocation* node);
+  virtual void VisitConstructorInvocation(ConstructorInvocation* node);
+  virtual void VisitIsExpression(IsExpression* node);
+  virtual void VisitAsExpression(AsExpression* node);
+  virtual void VisitConditionalExpression(ConditionalExpression* node);
+  virtual void VisitLogicalExpression(LogicalExpression* node);
+  virtual void VisitNot(Not* node);
+  virtual void VisitThisExpression(ThisExpression* node);
+  virtual void VisitStringConcatenation(StringConcatenation* node);
+  virtual void VisitListLiteral(ListLiteral* node);
+  virtual void VisitMapLiteral(MapLiteral* node);
+  virtual void VisitFunctionExpression(FunctionExpression* node);
+  virtual void VisitLet(Let* node);
+  virtual void VisitThrow(Throw* node);
+  virtual void VisitRethrow(Rethrow* node);
+
+  virtual void VisitInvalidStatement(InvalidStatement* node);
+  virtual void VisitEmptyStatement(EmptyStatement* node);
+  virtual void VisitBlock(Block* node);
+  virtual void VisitReturnStatement(ReturnStatement* node);
+  virtual void VisitExpressionStatement(ExpressionStatement* node);
+  virtual void VisitVariableDeclaration(VariableDeclaration* node);
+  virtual void VisitFunctionDeclaration(FunctionDeclaration* node);
+  virtual void VisitIfStatement(IfStatement* node);
+  virtual void VisitWhileStatement(WhileStatement* node);
+  virtual void VisitDoStatement(DoStatement* node);
+  virtual void VisitForStatement(ForStatement* node);
+  virtual void VisitForInStatement(ForInStatement* node);
+  virtual void VisitLabeledStatement(LabeledStatement* node);
+  virtual void VisitBreakStatement(BreakStatement* node);
+  virtual void VisitSwitchStatement(SwitchStatement* node);
+  virtual void VisitContinueSwitchStatement(ContinueSwitchStatement* node);
+  virtual void VisitAssertStatement(AssertStatement* node);
+  virtual void VisitTryFinally(TryFinally* node);
+  virtual void VisitTryCatch(TryCatch* node);
+  virtual void VisitYieldStatement(YieldStatement* node);
+
  private:
+  FlowGraph* BuildGraphOfFunction(FunctionNode* node,
+                                  Constructor* constructor = NULL);
+  FlowGraph* BuildGraphOfFieldAccessor(Field* node,
+                                       LocalVariable* setter_value);
+  FlowGraph* BuildGraphOfStaticFieldInitializer(Field* node);
   FlowGraph* BuildGraphOfMethodExtractor(const Function& method);
+  FlowGraph* BuildGraphOfImplicitClosureFunction(FunctionNode* kernel_function,
+                                                 const Function& function);
   FlowGraph* BuildGraphOfNoSuchMethodDispatcher(const Function& function);
   FlowGraph* BuildGraphOfInvokeFieldDispatcher(const Function& function);
 
-  Fragment NativeFunctionBody(intptr_t first_positional_offset,
+  Fragment NativeFunctionBody(FunctionNode* kernel_function,
                               const Function& function);
 
+  void SetupDefaultParameterValues(FunctionNode* function);
+
   TargetEntryInstr* BuildTargetEntry();
   JoinEntryInstr* BuildJoinEntry();
   JoinEntryInstr* BuildJoinEntry(intptr_t try_index);
 
+  Fragment TranslateArguments(Arguments* node, Array* argument_names);
   ArgumentArray GetArguments(int count);
 
+  Fragment TranslateInitializers(Class* kernel_class,
+                                 List<Initializer>* initialiers);
+  Fragment TranslateFieldInitializer(NameIndex canonical_name,
+                                     Expression* init);
+
+  Fragment TranslateStatement(Statement* statement);
+  Fragment TranslateCondition(Expression* expression, bool* negate);
+  Fragment TranslateExpression(Expression* expression);
+
   Fragment TranslateFinallyFinalizers(TryFinallyBlock* outer_finally,
                                       intptr_t target_context_depth);
 
+  Fragment TranslateFunctionNode(FunctionNode* node, TreeNode* parent);
+
+  Fragment EnterScope(TreeNode* node, bool* new_context = NULL);
   Fragment EnterScope(intptr_t kernel_offset, bool* new_context = NULL);
+  Fragment ExitScope(TreeNode* node);
   Fragment ExitScope(intptr_t kernel_offset);
 
   Fragment LoadContextAt(int depth);
   Fragment AdjustContextTo(int depth);
 
   Fragment PushContext(int size);
   Fragment PopContext();
 
   Fragment LoadInstantiatorTypeArguments();
   Fragment LoadFunctionTypeArguments();
@@ skipping 82 matching lines @@
   Fragment StringInterpolate(TokenPosition position);
   Fragment StringInterpolateSingle(TokenPosition position);
   Fragment ThrowTypeError();
   Fragment ThrowNoSuchMethodError();
   Fragment BuildImplicitClosureCreation(const Function& target);
   Fragment GuardFieldLength(const dart::Field& field, intptr_t deopt_id);
   Fragment GuardFieldClass(const dart::Field& field, intptr_t deopt_id);
 
   Fragment EvaluateAssertion();
   Fragment CheckReturnTypeInCheckedMode();
+  Fragment CheckVariableTypeInCheckedMode(VariableDeclaration* variable);
   Fragment CheckVariableTypeInCheckedMode(const AbstractType& dst_type,
                                           const dart::String& name_symbol);
   Fragment CheckBooleanInCheckedMode();
   Fragment CheckAssignableInCheckedMode(const dart::AbstractType& dst_type,
                                         const dart::String& dst_name);
 
   Fragment AssertBool();
   Fragment AssertAssignable(const dart::AbstractType& dst_type,
                             const dart::String& dst_name);
 
+  template <class Invocation>
+  bool RecognizeComparisonWithNull(Token::Kind token_kind, Invocation* node);
+
   bool NeedsDebugStepCheck(const Function& function, TokenPosition position);
   bool NeedsDebugStepCheck(Value* value, TokenPosition position);
   Fragment DebugStepCheck(TokenPosition position);
 
   dart::RawFunction* LookupMethodByMember(NameIndex target,
                                           const dart::String& method_name);
 
   LocalVariable* MakeTemporary();
   LocalVariable* MakeNonTemporary(const dart::String& symbol);
 
   intptr_t CurrentTryIndex();
   intptr_t AllocateTryIndex() { return next_used_try_index_++; }
 
+  void AddVariable(VariableDeclaration* declaration, LocalVariable* variable);
+  void AddParameter(VariableDeclaration* declaration,
+                    LocalVariable* variable,
+                    intptr_t pos);
   dart::LocalVariable* LookupVariable(VariableDeclaration* var);
   dart::LocalVariable* LookupVariable(intptr_t kernel_offset);
 
   void SetTempIndex(Definition* definition);
 
   void Push(Definition* definition);
   Value* Pop();
   Fragment Drop();
 
   bool IsInlining() { return exit_collector_ != NULL; }
 
   Token::Kind MethodKind(const dart::String& name);
 
   void InlineBailout(const char* reason);
 
   TranslationHelper translation_helper_;
   Thread* thread_;
   Zone* zone_;
 
-  intptr_t kernel_offset_;
+  // The node we are currently compiling (e.g. FunctionNode, Constructor,
+  // Field)
+  TreeNode* node_;
 
   ParsedFunction* parsed_function_;
   intptr_t osr_id_;
   const ZoneGrowableArray<const ICData*>& ic_data_array_;
   // Contains (deopt_id, context_level) pairs.
   ZoneGrowableArray<intptr_t>* context_level_array_;
   InlineExitCollector* exit_collector_;
 
   intptr_t next_block_id_;
   intptr_t AllocateBlockId() { return next_block_id_++; }
 
   intptr_t GetNextDeoptId() {
     intptr_t deopt_id = thread_->GetNextDeoptId();
     if (context_level_array_ != NULL) {
       intptr_t level = context_depth_;
       context_level_array_->Add(deopt_id);
       context_level_array_->Add(level);
     }
     return deopt_id;
   }
 
   intptr_t next_function_id_;
   intptr_t AllocateFunctionId() { return next_function_id_++; }
 
   intptr_t context_depth_;
   intptr_t loop_depth_;
   intptr_t try_depth_;
   intptr_t catch_depth_;
   intptr_t for_in_depth_;
+  Fragment fragment_;
   Value* stack_;
   intptr_t pending_argument_count_;
 
   GraphEntryInstr* graph_entry_;
 
   ScopeBuildingResult* scopes_;
 
   GrowableArray<YieldContinuation> yield_continuations_;
 
   LocalVariable* CurrentException() {
@@ skipping 23 matching lines @@
   // [TryCatchBlock] class.
   TryCatchBlock* try_catch_block_;
   intptr_t next_used_try_index_;
 
   // A chained list of catch blocks. Chaining and lookup is done by the
   // [CatchBlock] class.
   CatchBlock* catch_block_;
 
   ActiveClass active_class_;
   DartTypeTranslator type_translator_;
+  ConstantEvaluator constant_evaluator_;
 
   StreamingFlowGraphBuilder* streaming_flow_graph_builder_;
 
   friend class BreakableBlock;
   friend class CatchBlock;
   friend class ConstantEvaluator;
   friend class DartTypeTranslator;
   friend class StreamingFlowGraphBuilder;
   friend class ScopeBuilder;
   friend class SwitchBlock;
@@ skipping 239 matching lines @@
 namespace kernel {
 
 RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(const Function& function);
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_