Add Genericity enum in VM to distinguish how a type is uninstantiated.

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, 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 "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 1200 matching lines @@
   return;
 }
 
 
 void ValueGraphVisitor::VisitTypeNode(TypeNode* node) {
   const AbstractType& type = node->type();
   // Type may be malbounded, but not malformed.
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   if (type.IsInstantiated()) {
     ReturnDefinition(new (Z) ConstantInstr(type));
+    return;
+  }
+  const TokenPosition token_pos = node->token_pos();
+  Value* instantiator_type_arguments = NULL;
+  if (type.IsInstantiated(kClass)) {
+    instantiator_type_arguments = BuildNullValue(token_pos);
   } else {
-    const Class& instantiator_class =
-        Class::ZoneHandle(Z, owner()->function().Owner());
-    Value* instantiator_value = BuildInstantiatorTypeArguments(
-        node->token_pos(), instantiator_class, NULL);
-    ReturnDefinition(new (Z) InstantiateTypeInstr(
-        node->token_pos(), type, instantiator_class, instantiator_value));
+    instantiator_type_arguments = BuildInstantiatorTypeArguments(token_pos);
   }
+  Value* function_type_arguments = NULL;
+  if (type.IsInstantiated(kCurrentFunction)) {
+    // TODO(regis): function_type_arguments = BuildNullValue((token_pos);
+  } else {
+    function_type_arguments = BuildFunctionTypeArguments(token_pos);
+  }
+  ReturnDefinition(new (Z) InstantiateTypeInstr(
+      token_pos, type, instantiator_type_arguments, function_type_arguments));
 }
 
 
 // Returns true if the type check can be skipped, for example, if the
 // destination type is dynamic or if the compile type of the value is a subtype
 // of the destination type.
 bool EffectGraphVisitor::CanSkipTypeCheck(TokenPosition token_pos,
                                           Value* value,
                                           const AbstractType& dst_type,
                                           const String& dst_name) {
@@ skipping 158 matching lines @@
       Join(for_test, for_true, for_right);
     }
     ReturnDefinition(BuildLoadExprTemp(node->token_pos()));
     return;
   }
 
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
-void EffectGraphVisitor::BuildTypecheckPushArguments(
-    TokenPosition token_pos,
-    PushArgumentInstr** push_instantiator_type_arguments_result) {
-  const Class& instantiator_class =
-      Class::Handle(Z, owner()->function().Owner());
-  // Since called only when type tested against is not instantiated.
-  ASSERT(instantiator_class.IsGeneric());
-  Value* instantiator_type_arguments = NULL;
-  Value* instantiator = BuildInstantiator(token_pos);
-  if (instantiator == NULL) {
-    // No instantiator when inside factory.
-    instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
+PushArgumentInstr* EffectGraphVisitor::PushInstantiatorTypeArguments(
+    const AbstractType& type,
+    TokenPosition token_pos) {
+  if (type.IsInstantiated(kClass)) {
+    return PushArgument(BuildNullValue(token_pos));
   } else {
-    instantiator_type_arguments = BuildInstantiatorTypeArguments(
-        token_pos, instantiator_class, instantiator);
+    Value* instantiator_type_args = BuildInstantiatorTypeArguments(token_pos);
+    return PushArgument(instantiator_type_args);
   }
-  *push_instantiator_type_arguments_result =
-      PushArgument(instantiator_type_arguments);
 }
 
 
-void EffectGraphVisitor::BuildTypecheckArguments(
-    TokenPosition token_pos,
-    Value** instantiator_type_arguments_result) {
-  Value* instantiator = NULL;
-  Value* instantiator_type_arguments = NULL;
-  const Class& instantiator_class =
-      Class::Handle(Z, owner()->function().Owner());
-  // Since called only when type tested against is not instantiated.
-  ASSERT(instantiator_class.IsGeneric());
-  instantiator = BuildInstantiator(token_pos);
-  if (instantiator == NULL) {
-    // No instantiator when inside factory.
-    instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
+PushArgumentInstr* EffectGraphVisitor::PushFunctionTypeArguments(
+    const AbstractType& type,
+    TokenPosition token_pos) {
+  if (type.IsInstantiated(kCurrentFunction)) {
+    return PushArgument(BuildNullValue(token_pos));
   } else {
-    instantiator_type_arguments = BuildInstantiatorTypeArguments(
-        token_pos, instantiator_class, instantiator);
+    Value* function_type_args = BuildFunctionTypeArguments(token_pos);
+    return PushArgument(function_type_args);
   }
-  *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue(TokenPosition token_pos) {
   return Bind(
       new (Z) ConstantInstr(Object::ZoneHandle(Z, Object::null()), token_pos));
 }
 
 
 // Used for testing incoming arguments.
 AssertAssignableInstr* EffectGraphVisitor::BuildAssertAssignable(
     TokenPosition token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
-  if (dst_type.IsInstantiated()) {
+  Value* function_type_arguments = NULL;
+  if (dst_type.IsInstantiated(kClass)) {
     instantiator_type_arguments = BuildNullValue(token_pos);
   } else {
-    BuildTypecheckArguments(token_pos, &instantiator_type_arguments);
+    instantiator_type_arguments = BuildInstantiatorTypeArguments(token_pos);
+  }
+  if (dst_type.IsInstantiated(kCurrentFunction)) {
+    // TODO(regis): function_type_arguments = BuildNullValue(token_pos);
+  } else {
+    function_type_arguments = BuildFunctionTypeArguments(token_pos);
   }
 
   const intptr_t deopt_id = Thread::Current()->GetNextDeoptId();
-  return new (Z)
-      AssertAssignableInstr(token_pos, value, instantiator_type_arguments,
-                            dst_type, dst_name, deopt_id);
+  return new (Z) AssertAssignableInstr(
+      token_pos, value, instantiator_type_arguments, function_type_arguments,
+      dst_type, dst_name, deopt_id);
 }
 
 
 // Used for type casts and to test assignments.
 Value* EffectGraphVisitor::BuildAssignableValue(TokenPosition token_pos,
                                                 Value* value,
                                                 const AbstractType& dst_type,
                                                 const String& dst_name) {
   if (CanSkipTypeCheck(token_pos, value, dst_type, dst_name)) {
     return value;
@@ skipping 36 matching lines @@
     return;
   }
   ValueGraphVisitor for_left_value(owner());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
 
   // We now know type is a real class (!num, !int, !smi, !string)
   // and the type check could NOT be removed at compile time.
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
   if (simpleInstanceOfType(type)) {
-    ASSERT(!node->right()->AsTypeNode()->type().IsNull());
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new (Z) ZoneGrowableArray<PushArgumentInstr*>(2);
     arguments->Add(push_left);
     Value* type_const = Bind(new (Z) ConstantInstr(type));
     arguments->Add(PushArgument(type_const));
     const intptr_t kNumArgsChecked = 2;
     Definition* result = new (Z) InstanceCallInstr(
         node->token_pos(),
         Library::PrivateCoreLibName(Symbols::_simpleInstanceOf()), node->kind(),
         arguments,
         Object::null_array(),  // No argument names.
         kNumArgsChecked, owner()->ic_data_array());
     if (negate_result) {
       result = new (Z) BooleanNegateInstr(Bind(result));
     }
     ReturnDefinition(result);
     return;
   }
 
-  PushArgumentInstr* push_type_args = NULL;
-  if (type.IsInstantiated()) {
-    push_type_args = PushArgument(BuildNullValue(node->token_pos()));
-  } else {
-    BuildTypecheckPushArguments(node->token_pos(), &push_type_args);
-  }
+  PushArgumentInstr* push_instantiator_type_args =
+      PushInstantiatorTypeArguments(type, node->token_pos());
+  // TODO(regis): PushArgumentInstr* push_function_type_args =
+  //    PushFunctionTypeArguments(type, node->token_pos());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(3);
   arguments->Add(push_left);
-  arguments->Add(push_type_args);
-  ASSERT(!node->right()->AsTypeNode()->type().IsNull());
+  arguments->Add(push_instantiator_type_args);
+  // TODO(regis): arguments->Add(push_function_type_args);
   Value* type_const = Bind(new (Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_const));
   const intptr_t kNumArgsChecked = 1;
   Definition* result = new (Z) InstanceCallInstr(
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_instanceOf()),
       node->kind(), arguments,
       Object::null_array(),  // No argument names.
       kNumArgsChecked, owner()->ic_data_array());
   if (negate_result) {
     result = new (Z) BooleanNegateInstr(Bind(result));
   }
   ReturnDefinition(result);
 }
 
 
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   ASSERT(!node->right()->AsTypeNode()->type().IsNull());
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed() && !type.IsMalbounded());
   ValueGraphVisitor for_value(owner());
   node->left()->Visit(&for_value);
   Append(for_value);
   if (CanSkipTypeCheck(node->token_pos(), for_value.value(), type,
                        Symbols::InTypeCast())) {
     ReturnValue(for_value.value());
     return;
   }
   PushArgumentInstr* push_left = PushArgument(for_value.value());
-  PushArgumentInstr* push_type_args = NULL;
-  if (type.IsInstantiated()) {
-    push_type_args = PushArgument(BuildNullValue(node->token_pos()));
-  } else {
-    BuildTypecheckPushArguments(node->token_pos(), &push_type_args);
-  }
+  PushArgumentInstr* push_instantiator_type_args =
+      PushInstantiatorTypeArguments(type, node->token_pos());
+  // TODO(regis): PushArgumentInstr* push_function_type_args =
+  //    PushFunctionTypeArguments(type, node->token_pos());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new (Z) ZoneGrowableArray<PushArgumentInstr*>(3);
   arguments->Add(push_left);
-  arguments->Add(push_type_args);
+  arguments->Add(push_instantiator_type_args);
+  // TODO(regis): arguments->Add(push_function_type_args);
   Value* type_arg = Bind(new (Z) ConstantInstr(type));
   arguments->Add(PushArgument(type_arg));
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       node->token_pos(), Library::PrivateCoreLibName(Symbols::_as()),
       node->kind(), arguments,
       Object::null_array(),  // No argument names.
       kNumArgsChecked, owner()->ic_data_array());
   ReturnDefinition(call);
 }
@@ skipping 754 matching lines @@
   Value* closure_val = Bind(alloc);
   {
     LocalVariable* closure_tmp_var = EnterTempLocalScope(closure_val);
     // Store instantiator type arguments if scope class is generic.
     const Type& function_type = Type::ZoneHandle(Z, function.SignatureType());
     const Class& scope_cls = Class::ZoneHandle(Z, function_type.type_class());
     if (scope_cls.IsGeneric()) {
       ASSERT(function.Owner() == scope_cls.raw());
       Value* closure_tmp_val =
           Bind(new (Z) LoadLocalInstr(*closure_tmp_var, node->token_pos()));
-      const Class& instantiator_class =
-          Class::Handle(Z, owner()->function().Owner());
-      Value* type_arguments = BuildInstantiatorTypeArguments(
-          node->token_pos(), instantiator_class, NULL);
+      Value* type_arguments = BuildInstantiatorTypeArguments(node->token_pos());
       Do(new (Z) StoreInstanceFieldInstr(Closure::instantiator_offset(),
                                          closure_tmp_val, type_arguments,
                                          kEmitStoreBarrier, node->token_pos()));
     }
 
     // Store function.
     Value* closure_tmp_val =
         Bind(new (Z) LoadLocalInstr(*closure_tmp_var, node->token_pos()));
     Value* func_val =
         Bind(new (Z) ConstantInstr(Function::ZoneHandle(Z, function.raw())));
@@ skipping 302 matching lines @@
     return NULL;
   }
 
   LocalVariable* instantiator = owner()->parsed_function().instantiator();
   ASSERT(instantiator != NULL);
   Value* result = Bind(BuildLoadLocal(*instantiator, token_pos));
   return result;
 }
 
 
-// 'expression_temp_var' may not be used inside this method if 'instantiator'
-// is not NULL.
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
-    TokenPosition token_pos,
-    const Class& instantiator_class,
-    Value* instantiator) {
+    TokenPosition token_pos) {
+  const Class& instantiator_class =
+      Class::Handle(Z, owner()->function().Owner());
   if (!instantiator_class.IsGeneric()) {
     // The type arguments are compile time constants.
     TypeArguments& type_arguments =
         TypeArguments::ZoneHandle(Z, TypeArguments::null());
     // Type is temporary. Only its type arguments are preserved.
     Type& type = Type::Handle(Z, Type::New(instantiator_class, type_arguments,
                                            token_pos, Heap::kNew));
     type ^= ClassFinalizer::FinalizeType(instantiator_class, type,
                                          ClassFinalizer::kFinalize);
     ASSERT(!type.IsMalformedOrMalbounded());
     type_arguments = type.arguments();
     type_arguments = type_arguments.Canonicalize();
     return Bind(new (Z) ConstantInstr(type_arguments));
   }
   Function& outer_function = Function::Handle(Z, owner()->function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
-    // No instantiator for factories.
-    ASSERT(instantiator == NULL);
+    // Note that in the factory case, the instantiator is the first parameter
+    // of the factory, i.e. already a TypeArguments object.
     LocalVariable* instantiator_var = owner()->parsed_function().instantiator();
     ASSERT(instantiator_var != NULL);
     return Bind(BuildLoadLocal(*instantiator_var, token_pos));
   }
-  if (instantiator == NULL) {
-    instantiator = BuildInstantiator(token_pos);
-  }
   // The instantiator is the receiver of the caller, which is not a factory.
   // The receiver cannot be null; extract its TypeArguments object.
-  // Note that in the factory case, the instantiator is the first parameter
-  // of the factory, i.e. already a TypeArguments object.
+  Value* instantiator = BuildInstantiator(token_pos);
   intptr_t type_arguments_field_offset =
       instantiator_class.type_arguments_field_offset();
   ASSERT(type_arguments_field_offset != Class::kNoTypeArguments);
 
   return Bind(new (Z) LoadFieldInstr(
       instantiator, type_arguments_field_offset,
       Type::ZoneHandle(Z, Type::null()),  // Not an instance, no type.
       token_pos));
 }
 
 
+Value* EffectGraphVisitor::BuildFunctionTypeArguments(TokenPosition token_pos) {
+  UNIMPLEMENTED();
+  return NULL;
+}
+
+
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     TokenPosition token_pos,
     const TypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(new (Z) ConstantInstr(type_arguments));
   }
   // The type arguments are uninstantiated.
   const Class& instantiator_class =
       Class::ZoneHandle(Z, owner()->function().Owner());
-  Value* instantiator_value =
-      BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
+  Value* instantiator_type_args = BuildInstantiatorTypeArguments(token_pos);
   const bool use_instantiator_type_args =
       type_arguments.IsUninstantiatedIdentity() ||
       type_arguments.CanShareInstantiatorTypeArguments(instantiator_class);
   if (use_instantiator_type_args) {
-    return instantiator_value;
+    return instantiator_type_args;
+  }
+  Value* function_type_args = NULL;
+  if (type_arguments.IsInstantiated(kCurrentFunction)) {
+    // TODO(regis): function_type_args = BuildNullValue(token_pos);
   } else {
-    return Bind(new (Z) InstantiateTypeArgumentsInstr(
-        token_pos, type_arguments, instantiator_class, instantiator_value));
+    function_type_args = BuildFunctionTypeArguments(token_pos);
   }
+  return Bind(new (Z) InstantiateTypeArgumentsInstr(
+      token_pos, type_arguments, instantiator_class, instantiator_type_args,
+      function_type_args));
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
@@ skipping 1577 matching lines @@
       graph_entry_->PruneUnreachable(graph_entry_, NULL, osr_id_, block_marks);
   ASSERT(found);
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) const {
   parsed_function_.Bailout("FlowGraphBuilder", reason);
 }
 
 }  // namespace dart