Add convenience static members of Type: Smi and Mint.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 907 matching lines @@
 
 
 RawAbstractType* AllocateObjectWithBoundsCheckComp::CompileType() const {
   // TODO(regis): Be more specific.
   return Type::DynamicType();
 }
 
 
 RawAbstractType* LoadVMFieldComp::CompileType() const {
   // Type may be null if the field is a VM field, e.g. context parent.
-  return type().raw();
+  if (type().IsNull()) {
+    return AbstractType::null();

[srdjan, 2012/08/23 19:12:59]

Please add comment why is that necessary, why we cannot just return type().raw()

[regis, 2012/08/23 21:03:34]

In production mode, the type of the local is not guaranteed and we return
Dynamic, but it would be wrong to return Dynamic when the type should never be
used (null).
Added comment.

+  }
+  if (FLAG_enable_type_checks) {
+    return type().raw();
+  }
+  return Type::DynamicType();
 }
 
 
 RawAbstractType* StoreVMFieldComp::CompileType() const {
   return value()->CompileType();
 }
 
 
 RawAbstractType* InstantiateTypeArgumentsComp::CompileType() const {
   return AbstractType::null();
@@ skipping 29 matching lines @@
   return AbstractType::null();
 }
 
 
 RawAbstractType* CheckStackOverflowComp::CompileType() const {
   return AbstractType::null();
 }
 
 
 RawAbstractType* BinarySmiOpComp::CompileType() const {
-  ObjectStore* object_store = Isolate::Current()->object_store();
-  return (op_kind() == Token::kSHL)
-      ? Type::IntInterface()
-      : object_store->smi_type();
+  return (op_kind() == Token::kSHL) ? Type::IntInterface() : Type::SmiType();
 }
 
 
 intptr_t BinarySmiOpComp::ResultCid() const {
   return (op_kind() == Token::kSHL) ? kDynamicCid : kSmiCid;
 }
 
 
 bool BinarySmiOpComp::CanDeoptimize() const {
   switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       return false;
     default:
       return true;
   }
 }
 
 
 RawAbstractType* BinaryMintOpComp::CompileType() const {
-  ObjectStore* object_store = Isolate::Current()->object_store();
-  return object_store->mint_type();
+  return Type::MintType();
 }
 
 
 intptr_t BinaryMintOpComp::ResultCid() const {
   return kMintCid;
 }
 
 
 RawAbstractType* BinaryDoubleOpComp::CompileType() const {
   return Type::DoubleInterface();
 }
 
 
 intptr_t BinaryDoubleOpComp::ResultCid() const {
   return kDoubleCid;
 }
 
 
 RawAbstractType* UnarySmiOpComp::CompileType() const {
-  return Type::IntInterface();
+  return Type::SmiType();
 }
 
 
 RawAbstractType* NumberNegateComp::CompileType() const {
   // Implemented only for doubles.
   return Type::DoubleInterface();
 }
 
 
 RawAbstractType* DoubleToDoubleComp::CompileType() const {
@@ skipping 495 matching lines @@
                      ? UseDefinition(values()[i]->AsUse()->definition())
                      : val);
   }
   return copy;
 }
 
 
 #undef __
 
 }  // namespace dart