Revert "Integrate the Irregexp Regular Expression Engine."

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.
 
 #include "vm/flow_graph_type_propagator.h"
 
 #include "vm/cha.h"
 #include "vm/bit_vector.h"
 #include "vm/il_printer.h"
-#include "vm/regexp_assembler.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_type_propagation, false,
             "Trace flow graph type propagation");
 
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, propagate_types);
 DECLARE_FLAG(bool, use_cha);
 
@@ skipping 682 matching lines @@
   // Parameters at catch blocks and OSR entries have type dynamic.
   //
   // TODO(kmillikin): Use the actual type of the parameter at OSR entry.
   // The code below is not safe for OSR because it doesn't necessarily use
   // the correct scope.
   if ((graph_entry == NULL) || graph_entry->IsCompiledForOsr()) {
     return CompileType::Dynamic();
   }
 
   const Function& function = graph_entry->parsed_function().function();
-  if (function.IsIrregexpFunction()) {
-    // In irregexp functions, types of input parameters are known and immutable.
-    // Set parameter types here in order to prevent unnecessary CheckClassInstr
-    // from being generated.
-    switch (index()) {
-      case RegExpMacroAssembler::kParamStringIndex:
-        return CompileType::FromCid(function.regexp_cid());
-      case RegExpMacroAssembler::kParamStartOffsetIndex:
-        return CompileType::FromCid(kSmiCid);
-      default: UNREACHABLE();
-    }
-    UNREACHABLE();
-    return CompileType::Dynamic();
-  }
-
   LocalScope* scope = graph_entry->parsed_function().node_sequence()->scope();
   const AbstractType& type = scope->VariableAt(index())->type();
 
   // Parameter is the constructor phase.
   if ((index() == 1) && function.IsConstructor()) {
     return CompileType::FromAbstractType(type, CompileType::kNonNullable);
   }
 
   // Parameter is the receiver.
   if ((index() == 0) &&
@@ skipping 266 matching lines @@
       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)
-                                 : CompileType::Int();
-    default:
-      UNIMPLEMENTED();
-      return CompileType::Dynamic();
-  }
-}
-
-
 CompileType BinaryInt32OpInstr::ComputeType() const {
   // TODO(vegorov): range analysis information shall be used here.
   return CompileType::Int();
 }
 
 
 CompileType BinarySmiOpInstr::ComputeType() const {
   return CompileType::FromCid(kSmiCid);
 }
 
@@ skipping 239 matching lines @@
 CompileType MathUnaryInstr::ComputeType() const {
   return CompileType::FromCid(kDoubleCid);
 }
 
 
 CompileType MathMinMaxInstr::ComputeType() const {
   return CompileType::FromCid(result_cid_);
 }
 
 
-CompileType CaseInsensitiveCompareUC16Instr::ComputeType() const {
-  return CompileType::FromCid(kBoolCid);
-}
-
-
 CompileType UnboxInstr::ComputeType() const {
   switch (representation()) {
     case kUnboxedDouble:
       return CompileType::FromCid(kDoubleCid);
 
     case kUnboxedFloat32x4:
       return CompileType::FromCid(kFloat32x4Cid);
 
     case kUnboxedFloat64x2:
       return CompileType::FromCid(kFloat64x2Cid);
@@ skipping 71 matching lines @@
 CompileType MergedMathInstr::ComputeType() const {
   return CompileType::Dynamic();
 }
 
 
 CompileType ExtractNthOutputInstr::ComputeType() const {
   return CompileType::FromCid(definition_cid_);
 }
 
 }  // namespace dart