[vm] Remove Dart_MakeExternalString and --support-externalizable-strings

runtime/vm/flow_graph_type_propagator.cc

 // Copyright (c) 2013, 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.
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/flow_graph_type_propagator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 276 matching lines @@
     SetCid(instr->ArgumentAt(0), instr->targets().MonomorphicReceiverCid());
     return;
   }
   CheckNonNullSelector(instr, instr->ArgumentAt(0),
                        instr->instance_call()->function_name());
 }
 
 void FlowGraphTypePropagator::VisitGuardFieldClass(
     GuardFieldClassInstr* guard) {
   const intptr_t cid = guard->field().guarded_cid();
-  if ((cid == kIllegalCid) || (cid == kDynamicCid) ||
-      Field::IsExternalizableCid(cid)) {
+  if ((cid == kIllegalCid) || (cid == kDynamicCid)) {
     return;
   }
 
   Definition* def = guard->value()->definition();
   CompileType* current = TypeOf(def);
   if (current->IsNone() || (current->ToCid() != cid) ||
       (current->is_nullable() && !guard->field().is_nullable())) {
     const bool is_nullable =
         guard->field().is_nullable() && current->is_nullable();
     SetTypeOf(def, new CompileType(is_nullable, cid, NULL));
@@ skipping 540 matching lines @@
 CompileType PushArgumentInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
 CompileType ConstantInstr::ComputeType() const {
   if (value().IsNull()) {
     return CompileType::Null();
   }
 
   intptr_t cid = value().GetClassId();
-  if (Field::IsExternalizableCid(cid)) {
-    cid = kDynamicCid;
-  }
 
   if (value().IsInstance()) {
     // Allocate in old-space since this may be invoked from the
     // background compiler.
     return CompileType::Create(
         cid,
         AbstractType::ZoneHandle(Instance::Cast(value()).GetType(Heap::kOld)));
   } else {
     // Type info for non-instance objects.
     return CompileType::FromCid(cid);
@@ skipping 143 matching lines @@
       if ((obj.raw() != Object::sentinel().raw()) &&
           (obj.raw() != Object::transition_sentinel().raw()) && !obj.IsNull()) {
         is_nullable = CompileType::kNonNullable;
         cid = obj.GetClassId();
       }
     } else if (field.guarded_cid() != kIllegalCid) {
       cid = field.guarded_cid();
       if (!IsNullableCid(cid)) is_nullable = CompileType::kNonNullable;
     }
   }
-  if (Field::IsExternalizableCid(cid)) {
-    cid = kDynamicCid;
-  }
   return CompileType(is_nullable, cid, abstract_type);
 }
 
 CompileType CreateArrayInstr::ComputeType() const {
   // TODO(fschneider): Add abstract type and type arguments to the compile type.
   return CompileType::FromCid(kArrayCid);
 }
 
 CompileType AllocateObjectInstr::ComputeType() const {
   if (!closure_function().IsNull()) {
@@ skipping 16 matching lines @@
 CompileType LoadFieldInstr::ComputeType() const {
   // Type may be null if the field is a VM field, e.g. context parent.
   // Keep it as null for debug purposes and do not return dynamic in production
   // mode, since misuse of the type would remain undetected.
   if (type().IsNull()) {
     return CompileType::Dynamic();
   }
 
   const AbstractType* abstract_type = NULL;
   if (Isolate::Current()->type_checks() &&
-      (type().IsFunctionType() ||
-       (type().HasResolvedTypeClass() &&
-        !Field::IsExternalizableCid(
-            Class::Handle(type().type_class()).id())))) {
+      (type().IsFunctionType() || type().HasResolvedTypeClass())) {
     abstract_type = &type();
   }
 
   if ((field_ != NULL) && (field_->guarded_cid() != kIllegalCid)) {
     bool is_nullable = field_->is_nullable();
     intptr_t field_cid = field_->guarded_cid();
-    if (Field::IsExternalizableCid(field_cid)) {
-      // We cannot assume that the type of the value in the field has not
-      // changed on the fly.
-      field_cid = kDynamicCid;
-    }
     return CompileType(is_nullable, field_cid, abstract_type);
   }
 
-  ASSERT(!Field::IsExternalizableCid(result_cid_));
   return CompileType::Create(result_cid_, *abstract_type);
 }
 
 CompileType LoadCodeUnitsInstr::ComputeType() const {
   switch (class_id()) {
     case kOneByteStringCid:
     case kExternalOneByteStringCid:
     case kTwoByteStringCid:
     case kExternalTwoByteStringCid:
       return can_pack_into_smi() ? CompileType::FromCid(kSmiCid)
@@ skipping 301 matching lines @@
   return CompileType::Dynamic();
 }
 
 CompileType ExtractNthOutputInstr::ComputeType() const {
   return CompileType::FromCid(definition_cid_);
 }
 
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)