VM: [Kernel] Set types on [LocalVariable] if they were introduced by [VariableDeclaration]s

runtime/vm/kernel_to_il.cc

 // 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.
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 12 matching lines @@
 DECLARE_FLAG(bool, support_externalizable_strings);
 
 namespace kernel {
 
 #define Z (zone_)
 #define H (translation_helper_)
 #define T (type_translator_)
 #define I Isolate::Current()
 
 
+static void DiscoverEnclosingElements(Zone* zone,
+                                      const Function& function,
+                                      Function* outermost_function,
+                                      TreeNode** outermost_node,
+                                      Class** klass) {
+  // Find out if there is an enclosing kernel class (which will be used to
+  // resolve type parameters).
+  *outermost_function = function.raw();
+  while (outermost_function->parent_function() != Object::null()) {
+    *outermost_function = outermost_function->parent_function();
+  }
+  *outermost_node =
+      static_cast<TreeNode*>(outermost_function->kernel_function());
+  if (*outermost_node != NULL) {
+    TreeNode* parent = NULL;
+    if ((*outermost_node)->IsProcedure()) {
+      parent = Procedure::Cast(*outermost_node)->parent();
+    } else if ((*outermost_node)->IsConstructor()) {
+      parent = Constructor::Cast(*outermost_node)->parent();
+    } else if ((*outermost_node)->IsField()) {
+      parent = Field::Cast(*outermost_node)->parent();
+    }
+    if (parent != NULL && parent->IsClass()) *klass = Class::Cast(parent);
+  }
+}
+
+
 void ScopeBuilder::EnterScope(TreeNode* node) {
   scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
   result_->scopes.Insert(node, scope_);
 }
 
 
 void ScopeBuilder::ExitScope() { scope_ = scope_->parent(); }
 
 
-LocalVariable* ScopeBuilder::MakeVariable(const dart::String& name) {
-  return new (Z)
-      LocalVariable(TokenPosition::kNoSource,
-                    TokenPosition::kNoSource,
-                    name,
-                    Object::dynamic_type());
-}
-
-
 LocalVariable* ScopeBuilder::MakeVariable(const dart::String& name,
-                                          const Type& type) {
+                                          const AbstractType& type) {
   return new (Z) LocalVariable(TokenPosition::kNoSource,
                                TokenPosition::kNoSource,
                                name,
                                type);
 }
 
 
 void ScopeBuilder::AddParameters(FunctionNode* function, intptr_t pos) {
   List<VariableDeclaration>& positional = function->positional_parameters();
   for (intptr_t i = 0; i < positional.length(); ++i) {
     AddParameter(positional[i], pos++);
   }
   List<VariableDeclaration>& named = function->named_parameters();
   for (intptr_t i = 0; i < named.length(); ++i) {
     AddParameter(named[i], pos++);
   }
 }
 
 
 void ScopeBuilder::AddParameter(VariableDeclaration* declaration,
                                 intptr_t pos) {
-  LocalVariable* variable = MakeVariable(H.DartSymbol(declaration->name()));
+  LocalVariable* variable =
+      MakeVariable(H.DartSymbol(declaration->name()),
+                   T.TranslateVariableType(declaration));
   if (declaration->IsFinal()) {
     variable->set_is_final();
   }
   scope_->InsertParameterAt(pos, variable);
   result_->locals.Insert(declaration, variable);
 
   // The default value may contain 'let' bindings for which the constant
   // evaluator needs scope bindings.
   Expression* defaultValue = declaration->initializer();
   if (defaultValue != NULL) {
@@ skipping 25 matching lines @@
   }
 
   // No need to create variables for try/catch-statements inside
   // nested functions.
   if (depth_.function_ > 0) return;
   if (variables->length() >= nesting_depth) return;
 
   // If variable was not lifted by the transformer introduce a new
   // one into the current function scope.
   if (v == NULL) {
-    v = MakeVariable(GenerateName(prefix, nesting_depth - 1));
+    v = MakeVariable(GenerateName(prefix, nesting_depth - 1),
+                     AbstractType::dynamic_type());
 
     // If transformer did not lift the variable then there is no need
     // to lift it into the context when we encouter a YieldStatement.
     v->set_is_forced_stack();
     current_function_scope_->AddVariable(v);
   }
 
   variables->Add(v);
 }
 
@@ skipping 11 matching lines @@
                        depth_.catch_);
 }
 
 
 void ScopeBuilder::AddIteratorVariable() {
   if (depth_.function_ > 0) return;
   if (result_->iterator_variables.length() >= depth_.for_in_) return;
 
   ASSERT(result_->iterator_variables.length() == depth_.for_in_ - 1);
   LocalVariable* iterator =
-      MakeVariable(GenerateName(":iterator", depth_.for_in_ - 1));
+      MakeVariable(GenerateName(":iterator", depth_.for_in_ - 1),
+                   AbstractType::dynamic_type());
   current_function_scope_->AddVariable(iterator);
   result_->iterator_variables.Add(iterator);
 }
 
 
 void ScopeBuilder::LookupVariable(VariableDeclaration* declaration) {
   LocalVariable* variable = result_->locals.Lookup(declaration);
   if (variable == NULL) {
     // We have not seen a declaration of the variable, so it must be the
     // case that we are compiling a nested function and the variable is
@@ skipping 43 matching lines @@
 }
 
 
 void ScopeBuilder::AddVariable(VariableDeclaration* declaration) {
   // In case `declaration->IsConst()` the flow graph building will take care of
   // evaluating the constant and setting it via
   // `declaration->SetConstantValue()`.
   const dart::String& name = declaration->name()->is_empty()
                                  ? GenerateName(":var", name_index_++)
                                  : H.DartSymbol(declaration->name());
-  LocalVariable* variable = MakeVariable(name);
+  LocalVariable* variable =
+      MakeVariable(name, T.TranslateVariableType(declaration));
   if (declaration->IsFinal()) {
     variable->set_is_final();
   }
   scope_->AddVariable(variable);
   result_->locals.Insert(declaration, variable);
 }
 
 
 static bool IsStaticInitializer(const Function& function, Zone* zone) {
   return (function.kind() == RawFunction::kImplicitStaticFinalGetter) &&
          dart::String::Handle(zone, function.name())
              .StartsWith(Symbols::InitPrefix());
 }
 
 
 ScopeBuildingResult* ScopeBuilder::BuildScopes() {
   if (result_ != NULL) return result_;
 
   ASSERT(scope_ == NULL && depth_.loop_ == 0 && depth_.function_ == 0);
   result_ = new (Z) ScopeBuildingResult();
 
   ParsedFunction* parsed_function = parsed_function_;
   const dart::Function& function = parsed_function->function();
 
+  // Setup a [ActiveClassScope] and a [ActiveMemberScope] which will be used
+  // e.g. for type translation.
+  const dart::Class& klass =
+      dart::Class::Handle(zone_, parsed_function_->function().Owner());
+  Function& outermost_function = Function::Handle(Z);
+  TreeNode* outermost_node = NULL;
+  Class* kernel_klass = NULL;
+  DiscoverEnclosingElements(
+      Z, function, &outermost_function, &outermost_node, &kernel_klass);
+  // Use [klass]/[kernel_klass] as active class.  Type parameters will get
+  // resolved via [kernel_klass] unless we are nested inside a static factory
+  // in which case we will use [member].
+  ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
+  Member* member = ((outermost_node != NULL) && outermost_node->IsMember())
+                       ? Member::Cast(outermost_node)
+                       : NULL;
+  ActiveMemberScope active_member(&active_class_, member);
+
+
   LocalScope* enclosing_scope = NULL;
   if (function.IsLocalFunction()) {
     enclosing_scope = LocalScope::RestoreOuterScope(
         ContextScope::Handle(Z, function.context_scope()));
   }
   current_function_scope_ = scope_ = new (Z) LocalScope(enclosing_scope, 0, 0);
 
   LocalVariable* context_var = parsed_function->current_context_var();
   context_var->set_is_forced_stack();
   scope_->AddVariable(context_var);
@@ skipping 13 matching lines @@
         node = Procedure::Cast(node_)->function();
       } else if (node_->IsConstructor()) {
         node = Constructor::Cast(node_)->function();
       } else {
         node = FunctionNode::Cast(node_);
       }
       current_function_node_ = node;
 
       intptr_t pos = 0;
       if (function.IsClosureFunction()) {
-        LocalVariable* variable = MakeVariable(Symbols::ClosureParameter());
+        LocalVariable* variable =
+            MakeVariable(Symbols::ClosureParameter(),
+                         AbstractType::dynamic_type());
         variable->set_is_forced_stack();
         scope_->InsertParameterAt(pos++, variable);
       } else if (!function.is_static()) {
         // We use [is_static] instead of [IsStaticFunction] because the latter
         // returns `false` for constructors.
         dart::Class& klass = dart::Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
         LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
 
         // We visit instance field initializers because they might contain
         // [Let] expressions and we need to have a mapping.
         if (node_->IsConstructor()) {
           Class* klass = Class::Cast(Constructor::Cast(node_)->parent());
 
           for (intptr_t i = 0; i < klass->fields().length(); i++) {
             Field* field = klass->fields()[i];
             if (!field->IsStatic() && (field->initializer() != NULL)) {
               EnterScope(field);
               field->initializer()->AcceptExpressionVisitor(this);
               ExitScope();
             }
           }
         }
       } else if (function.IsFactory()) {
         LocalVariable* variable = MakeVariable(
-            Symbols::TypeArgumentsParameter(), AbstractType::dynamic_type());
+            Symbols::TypeArgumentsParameter(),
+            AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, variable);
         result_->type_arguments_variable = variable;
       }
       AddParameters(node, pos);
 
       // We generate a syntethic body for implicit closure functions - which
       // will forward the call to the real function.
       //     -> see BuildGraphOfImplicitClosureFunction
       if (!function.IsImplicitClosureFunction()) {
         node_->AcceptVisitor(this);
@@ skipping 12 matching lines @@
       bool is_method = !function.IsStaticFunction();
       intptr_t pos = 0;
       if (is_method) {
         dart::Class& klass = dart::Class::Handle(Z, function.Owner());
         Type& klass_type = H.GetCanonicalType(klass);
         LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
         scope_->InsertParameterAt(pos++, variable);
         result_->this_variable = variable;
       }
       if (is_setter) {
-        result_->setter_value = MakeVariable(Symbols::Value());
+        result_->setter_value = MakeVariable(
+            Symbols::Value(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, result_->setter_value);
       }
       break;
     }
     case RawFunction::kMethodExtractor: {
       // Add a receiver parameter.  Though it is captured, we emit code to
       // explicitly copy it to a fixed offset in a freshly-allocated context
       // instead of using the generic code for regular functions.
       // Therefore, it isn't necessary to mark it as captured here.
       dart::Class& klass = dart::Class::Handle(Z, function.Owner());
       Type& klass_type = H.GetCanonicalType(klass);
       LocalVariable* variable = MakeVariable(Symbols::This(), klass_type);
       scope_->InsertParameterAt(0, variable);
       result_->this_variable = variable;
       break;
     }
     case RawFunction::kNoSuchMethodDispatcher:
     case RawFunction::kInvokeFieldDispatcher:
       for (intptr_t i = 0; i < function.NumParameters(); ++i) {
         LocalVariable* variable = MakeVariable(
-            dart::String::ZoneHandle(Z, function.ParameterNameAt(i)));
+            dart::String::ZoneHandle(Z, function.ParameterNameAt(i)),
+            AbstractType::dynamic_type());
         scope_->InsertParameterAt(i, variable);
       }
       break;
     case RawFunction::kSignatureFunction:
     case RawFunction::kIrregexpFunction:
       UNREACHABLE();
   }
 
   parsed_function->AllocateVariables();
 
@@ skipping 154 matching lines @@
   VisitVariableDeclaration(node->variable());
   node->body()->AcceptStatementVisitor(this);
   ExitScope();
   --depth_.loop_;
   --depth_.for_in_;
 }
 
 
 void ScopeBuilder::AddSwitchVariable() {
   if ((depth_.function_ == 0) && (result_->switch_variable == NULL)) {
-    LocalVariable* variable = MakeVariable(Symbols::SwitchExpr());
+    LocalVariable* variable = MakeVariable(
+        Symbols::SwitchExpr(),
+        AbstractType::dynamic_type());
     variable->set_is_forced_stack();
     current_function_scope_->AddVariable(variable);
     result_->switch_variable = variable;
   }
 }
 
 
 void ScopeBuilder::VisitSwitchStatement(SwitchStatement* node) {
   AddSwitchVariable();
   node->VisitChildren(this);
 }
 
 
 void ScopeBuilder::VisitReturnStatement(ReturnStatement* node) {
   if ((depth_.function_ == 0) && (depth_.finally_ > 0) &&
       (result_->finally_return_variable == NULL)) {
     const dart::String& name = H.DartSymbol(":try_finally_return_value");
-    LocalVariable* variable = MakeVariable(name);
+    LocalVariable* variable = MakeVariable(
+        name,
+        AbstractType::dynamic_type());
     current_function_scope_->AddVariable(variable);
     result_->finally_return_variable = variable;
   }
   node->VisitChildren(this);
 }
 
 
 void ScopeBuilder::VisitTryCatch(TryCatch* node) {
   ++depth_.try_;
   AddTryVariables();
@@ skipping 2164 matching lines @@
 
 
 FlowGraph* FlowGraphBuilder::BuildGraph() {
   const dart::Function& function = parsed_function_->function();
 
   if (function.IsConstructorClosureFunction()) return NULL;
 
   dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function_->function().Owner());
 
-  // Find out if there is an enclosing kernel class (which will be used to
-  // resolve type parameters).
+  Function& outermost_function = Function::Handle(Z);
+  TreeNode* outermost_node = NULL;
   Class* kernel_klass = NULL;
-  dart::Function& topmost = dart::Function::Handle(Z, function.raw());
-  while (topmost.parent_function() != Object::null()) {
-    topmost = topmost.parent_function();
-  }
-  TreeNode* topmost_node = static_cast<TreeNode*>(topmost.kernel_function());
-  if (topmost_node != NULL) {
-    // Going up the closure->parent chain needs to result in a Procedure or
-    // Constructor.
-    TreeNode* parent = NULL;
-    if (topmost_node->IsProcedure()) {
-      parent = Procedure::Cast(topmost_node)->parent();
-    } else if (topmost_node->IsConstructor()) {
-      parent = Constructor::Cast(topmost_node)->parent();
-    } else if (topmost_node->IsField()) {
-      parent = Field::Cast(topmost_node)->parent();
-    }
-    if (parent != NULL && parent->IsClass()) kernel_klass = Class::Cast(parent);
-  }
+  DiscoverEnclosingElements(
+      Z, function, &outermost_function, &outermost_node, &kernel_klass);
 
   // Mark that we are using [klass]/[kernell_klass] as active class.  Resolving
   // of type parameters will get resolved via [kernell_klass] unless we are
   // nested inside a static factory in which case we will use [member].
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
-  Member* member = topmost_node != NULL && topmost_node->IsMember()
-                       ? Member::Cast(topmost_node)
+  Member* member = ((outermost_node != NULL) && outermost_node->IsMember())
+                       ? Member::Cast(outermost_node)
                        : NULL;
   ActiveMemberScope active_member(&active_class_, member);
 
   // The IR builder will create its own local variables and scopes, and it
   // will not need an AST.  The code generator will assume that there is a
   // local variable stack slot allocated for the current context and (I
   // think) that the runtime will expect it to be at a fixed offset which
   // requires allocating an unused expression temporary variable.
   scopes_ = parsed_function_->EnsureKernelScopes();
 
@@ skipping 67 matching lines @@
     LocalVariable* context = MakeTemporary();
 
     // Copy captured parameters from the stack into the context.
     LocalScope* scope = parsed_function_->node_sequence()->scope();
     intptr_t parameter_count = dart_function.NumParameters();
     intptr_t parameter_index = parsed_function_->first_parameter_index();
     for (intptr_t i = 0; i < parameter_count; ++i, --parameter_index) {
       LocalVariable* variable = scope->VariableAt(i);
       if (variable->is_captured()) {
         // There is no LocalVariable describing the on-stack parameter so
-        // create one directly.
+        // create one directly and use the same type.
         LocalVariable* parameter =
             new (Z) LocalVariable(TokenPosition::kNoSource,
                                   TokenPosition::kNoSource,
                                   Symbols::TempParam(),
-                                  Object::dynamic_type());
+                                  variable->type());
         parameter->set_index(parameter_index);
         // Mark the stack variable so it will be ignored by the code for
         // try/catch.
         parameter->set_is_captured_parameter(true);
 
         // Copy the parameter from the stack to the context.  Overwrite it
         // with a null constant on the stack so the original value is
         // eligible for garbage collection.
         body += LoadLocal(context);
         body += LoadLocal(parameter);
@@ skipping 932 matching lines @@
   bool saved_finalize = finalize_;
   finalize_ = false;
   H.SetFinalize(false);
   AbstractType& result = TranslateType(node);
   finalize_ = saved_finalize;
   H.SetFinalize(saved_finalize);
   return result;
 }
 
 
+const AbstractType& DartTypeTranslator::TranslateVariableType(
+    VariableDeclaration* variable) {
+  AbstractType& abstract_type = TranslateType(variable->type());
+
+  // We return a new `ZoneHandle` here on purpose: The intermediate language
+  // instructions do not make a copy of the handle, so we do it.
+  AbstractType& type = Type::ZoneHandle(Z);
+
+  if (abstract_type.IsMalformed()) {
+    type = AbstractType::dynamic_type().raw();
+  } else {
+    type = result_.raw();
+  }
+
+  return type;
+}
+
+
 void DartTypeTranslator::VisitInvalidType(InvalidType* node) {
   result_ = ClassFinalizer::NewFinalizedMalformedType(
       Error::Handle(Z),  // No previous error.
       dart::Script::Handle(Z, dart::Script::null()), TokenPosition::kNoSource,
       "[InvalidType] in Kernel IR.");
 }
 
 
 void DartTypeTranslator::VisitFunctionType(FunctionType* node) {
   // The spec describes in section "19.1 Static Types":
@@ skipping 1836 matching lines @@
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart