dart::CompileType Class Reference

#include <compile_type.h>

Inheritance diagram for dart::CompileType:

Public Member Functions
	CompileType (bool can_be_null, bool can_be_sentinel, intptr_t cid, const AbstractType *type)
	CompileType (const CompileType &other)
CompileType &	operator= (const CompileType &other)
bool	is_nullable () const
bool	can_be_sentinel () const
const AbstractType *	ToAbstractType ()
intptr_t	ToCid ()
intptr_t	ToNullableCid ()
bool	HasDecidableNullability ()
bool	IsNull ()
bool	IsSubtypeOf (const AbstractType &other)
bool	IsAssignableTo (const AbstractType &other)
bool	IsInstanceOf (const AbstractType &other)
CompileType	CopyNonNullable ()
CompileType	CopyNonSentinel ()
void	Union (CompileType *other)
bool	IsEqualTo (CompileType *other)
bool	IsNone () const
bool	IsObject () const
bool	IsInt ()
bool	IsDouble ()
bool	IsBool ()
bool	IsNullableInt ()
bool	IsNullableSmi ()
bool	IsNullableDouble ()
bool	IsNullableBool ()
bool	CanBeSmi ()
bool	CanBeFuture ()
bool	Specialize (GrowableArray< intptr_t > *class_ids)
void	PrintTo (BaseTextBuffer *f) const
void	PrintTo (JSONWriter *writer) const
const char *	ToCString () const
void	set_owner (Definition *owner)
Definition *	owner () const
void	Write (FlowGraphSerializer *s) const
	CompileType (FlowGraphDeserializer *d)
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

Static Public Member Functions
static CompileType	FromAbstractType (const AbstractType &type, bool can_be_null, bool can_be_sentinel)
static CompileType	FromCid (intptr_t cid)
static CompileType	FromUnboxedRepresentation (Representation rep)
static CompileType	FromRepresentation (Representation rep)
static CompileType	None ()
static CompileType	Dynamic ()
static CompileType	DynamicOrSentinel ()
static CompileType	Null ()
static CompileType	Bool ()
static CompileType	Int ()
static CompileType	Int32 ()
static CompileType	NullableInt ()
static CompileType	Smi ()
static CompileType	NullableSmi ()
static CompileType	NullableMint ()
static CompileType	Double ()
static CompileType	NullableDouble ()
static CompileType	String ()
static CompileType	Object ()
static CompileType *	ComputeRefinedType (CompileType *old_type, CompileType *new_type)

Static Public Attributes
static constexpr bool	kCanBeNull = true
static constexpr bool	kCannotBeNull = false
static constexpr bool	kCanBeSentinel = true
static constexpr bool	kCannotBeSentinel = false

Detailed Description

Definition at line 43 of file compile_type.h.

Constructor & Destructor Documentation

CompileType() [1/3]

dart::CompileType::CompileType ( bool  can_be_null, bool  can_be_sentinel, intptr_t  cid, const AbstractType *  type  )

inline

Definition at line 51 of file compile_type.h.

      : can_be_null_(can_be_null),
        can_be_sentinel_(can_be_sentinel),
        cid_(cid),
        type_(type) {}

CompileType() [2/3]

dart::CompileType::CompileType ( const CompileType &  other )

inline

Definition at line 60 of file compile_type.h.

      : ZoneAllocated(),
        can_be_null_(other.can_be_null_),
        can_be_sentinel_(other.can_be_sentinel_),
        cid_(other.cid_),
        type_(other.type_) {}

CompileType() [3/3]

dart::CompileType::CompileType ( FlowGraphDeserializer *  d )

explicit

Definition at line 527 of file il_serializer.cc.

    : can_be_null_(d->Read<bool>()),
      can_be_sentinel_(d->Read<bool>()),
      cid_(d->Read<classid_t>()),
      type_(nullptr) {
  if (d->Read<bool>()) {
    type_ = &d->Read<const AbstractType&>();
  }
}

Member Function Documentation

Bool()

CompileType dart::CompileType::Bool ( )

static

Definition at line 729 of file type_propagator.cc.

                              {
  return CompileType(kCannotBeNull, kCannotBeSentinel, kBoolCid,
                     &Type::ZoneHandle(Type::BoolType()));
}

can_be_sentinel()

bool dart::CompileType::can_be_sentinel ( ) const

inline

Definition at line 80 of file compile_type.h.

{ return can_be_sentinel_; }

CanBeFuture()

bool dart::CompileType::CanBeFuture

(

)

Definition at line 983 of file type_propagator.cc.

                              {
  Thread* thread = Thread::Current();
  Zone* zone = thread->zone();
  if (cid_ != kIllegalCid && cid_ != kDynamicCid) {
    if ((cid_ == kNullCid) || (cid_ == kNeverCid) ||
        IsInternalOnlyClassId(cid_) || cid_ == kTypeArgumentsCid) {
      return false;
    }
    const Class& cls =
        Class::Handle(zone, thread->isolate_group()->class_table()->At(cid_));
    return cls.is_future_subtype();
  }
 
  AbstractType& type = AbstractType::Handle(zone, ToAbstractType()->ptr());
  if (type.IsTypeParameter()) {
    type = TypeParameter::Cast(type).bound();
  }
  if (type.IsTypeParameter()) {
    // Type parameter bounds can be cyclic, do not bother handling them here.
    return true;
  }
  const intptr_t type_class_id = type.type_class_id();
  if (type_class_id == kDynamicCid || type_class_id == kVoidCid ||
      type_class_id == kInstanceCid || type_class_id == kFutureOrCid) {
    return true;
  }
  if ((type_class_id == kIllegalCid) || (type_class_id == kNullCid) ||
      (type_class_id == kNeverCid)) {
    return false;
  }
  const auto& cls = Class::Handle(zone, type.type_class());
  return CHA::ClassCanBeFuture(cls);
}

CanBeSmi()

bool dart::CompileType::CanBeSmi

(

)

Definition at line 975 of file type_propagator.cc.

                           {
  // Fast path for known cid.
  if (cid_ != kIllegalCid && cid_ != kDynamicCid) {
    return cid_ == kSmiCid;
  }
  return CanPotentiallyBeSmi(*ToAbstractType(), /*recurse=*/true);
}

ComputeRefinedType()

CompileType * dart::CompileType::ComputeRefinedType ( CompileType *  old_type, CompileType *  new_type  )

static

Definition at line 614 of file type_propagator.cc.

                                                                    {
  ASSERT(new_type != nullptr);
 
  // In general, prefer the newly inferred type over old type.
  // It is possible that new and old types are unrelated or do not intersect
  // at all (for example, in case of unreachable code).
 
  // Discard None type as it is used to denote an unknown type.
  if (old_type == nullptr || old_type->IsNone()) {
    return new_type;
  }
  if (new_type->IsNone()) {
    return old_type;
  }
 
  CompileType* preferred_type = nullptr;
 
  // Prefer exact Cid if known.
  const intptr_t new_type_cid = new_type->ToCid();
  const intptr_t old_type_cid = old_type->ToCid();
  if (new_type_cid != old_type_cid) {
    if (new_type_cid != kDynamicCid) {
      preferred_type = new_type;
    } else if (old_type_cid != kDynamicCid) {
      preferred_type = old_type;
    }
  }
 
  if (preferred_type == nullptr) {
    const AbstractType* old_abstract_type = old_type->ToAbstractType();
    const AbstractType* new_abstract_type = new_type->ToAbstractType();
 
    // Prefer 'int' if known.
    if (old_type->IsNullableInt()) {
      preferred_type = old_type;
    } else if (new_type->IsNullableInt()) {
      preferred_type = new_type;
    } else if (old_abstract_type->IsSubtypeOf(*new_abstract_type, Heap::kOld)) {
      // Prefer old type, as it is clearly more specific.
      preferred_type = old_type;
    } else {
      // Prefer new type as it is more recent, even though it might be
      // no better than the old type.
      preferred_type = new_type;
    }
  }
 
  // Refine non-nullability and whether it can be sentinel.
  const bool can_be_null = old_type->is_nullable() && new_type->is_nullable();
  const bool can_be_sentinel =
      old_type->can_be_sentinel() && new_type->can_be_sentinel();
 
  if ((preferred_type->is_nullable() && !can_be_null) ||
      (preferred_type->can_be_sentinel() && !can_be_sentinel)) {
    return new CompileType(can_be_null, can_be_sentinel, preferred_type->cid_,
                           preferred_type->type_);
  } else {
    ASSERT(preferred_type->is_nullable() == can_be_null);
    ASSERT(preferred_type->can_be_sentinel() == can_be_sentinel);
    return preferred_type;
  }
}

CopyNonNullable()

CompileType dart::CompileType::CopyNonNullable ( )

inline

Definition at line 113 of file compile_type.h.

                                {
    if (IsNull()) {
      // Represent a non-nullable null type (typically arising for
      // unreachable values) as None.
      return None();
    }
 
    return CompileType(kCannotBeNull, can_be_sentinel_, cid_, type_);
  }

CopyNonSentinel()

CompileType dart::CompileType::CopyNonSentinel ( )

inline

Definition at line 124 of file compile_type.h.

                                {
    return CompileType(can_be_null_, kCannotBeSentinel, cid_, type_);
  }

Double()

CompileType dart::CompileType::Double ( )

static

Definition at line 757 of file type_propagator.cc.

                                {
  return CompileType(kCannotBeNull, kCannotBeSentinel, kDoubleCid,
                     &Type::ZoneHandle(Type::Double()));
}

Dynamic()

CompileType dart::CompileType::Dynamic ( )

static

Definition at line 714 of file type_propagator.cc.

                                 {
  return CompileType(kCanBeNull, kCannotBeSentinel, kDynamicCid,
                     &Object::dynamic_type());
}

DynamicOrSentinel()

CompileType dart::CompileType::DynamicOrSentinel ( )

static

Definition at line 719 of file type_propagator.cc.

                                           {
  return CompileType(kCanBeNull, kCanBeSentinel, kDynamicCid,
                     &Object::dynamic_type());
}

FromAbstractType()

CompileType dart::CompileType::FromAbstractType ( const AbstractType &  type, bool  can_be_null, bool  can_be_sentinel  )

static

Definition at line 678 of file type_propagator.cc.

                                                                {
  return CompileType(can_be_null && !type.IsStrictlyNonNullable(),
                     can_be_sentinel, kIllegalCid, &type);
}

FromCid()

CompileType dart::CompileType::FromCid ( intptr_t  cid )

static

Definition at line 685 of file type_propagator.cc.

                                             {
  ASSERT(cid != kIllegalCid);
  if (cid == kDynamicCid) {
    return CompileType::Dynamic();
  }
  return CompileType(cid == kNullCid, cid == kSentinelCid, cid, nullptr);
}

FromRepresentation()

CompileType dart::CompileType::FromRepresentation ( Representation  rep )

static

Definition at line 705 of file type_propagator.cc.

                                                              {
  if (rep == kUntagged) return CompileType::Object();
  if (RepresentationUtils::IsUnboxed(rep)) {
    return FromUnboxedRepresentation(rep);
  }
  ASSERT(rep != kNoRepresentation);
  return CompileType::Dynamic();
}

FromUnboxedRepresentation()

CompileType dart::CompileType::FromUnboxedRepresentation ( Representation  rep )

static

Definition at line 693 of file type_propagator.cc.

                                                                     {
  ASSERT(rep != kTagged);
  ASSERT(rep != kUntagged);
  if (RepresentationUtils::IsUnboxedInteger(rep)) {
    if (!Boxing::RequiresAllocation(rep)) {
      return CompileType::Smi();
    }
    return CompileType::Int();
  }
  return CompileType::FromCid(Boxing::BoxCid(rep));
}

HasDecidableNullability()

bool dart::CompileType::HasDecidableNullability

(

)

Definition at line 840 of file type_propagator.cc.

                                          {
  return !can_be_null_ || IsNull();
}

Int()

CompileType dart::CompileType::Int ( )

static

Definition at line 734 of file type_propagator.cc.

                             {
  return FromAbstractType(Type::ZoneHandle(Type::IntType()), kCannotBeNull,
                          kCannotBeSentinel);
}

Int32()

CompileType dart::CompileType::Int32 ( )

static

Definition at line 739 of file type_propagator.cc.

                               {
#if defined(HAS_SMI_63_BITS)
  return FromCid(kSmiCid);
#else
  return Int();
#endif
}

is_nullable()

bool dart::CompileType::is_nullable ( ) const

inline

Definition at line 76 of file compile_type.h.

{ return can_be_null_; }

IsAssignableTo()

bool dart::CompileType::IsAssignableTo

(

const AbstractType &

other

)

Definition at line 882 of file type_propagator.cc.

                                                          {
  if (other.IsTopTypeForSubtyping()) {
    return true;
  }
  // If we allow comparisons against an uninstantiated type, then we can
  // end up incorrectly optimizing away AssertAssignables where the incoming
  // value and outgoing value have CompileTypes that would return true to the
  // subtype check below, but at runtime are instantiated with different type
  // argument vectors such that the relation does not hold for the runtime
  // instantiated values.
  //
  // We might consider using an approximation of the uninstantiated type,
  // like the instantiation to bounds, and compare to that. However, in
  // vm/dart/regress_b_230945329_test.dart we have a case where the compared
  // uninstantiated type is the same as the one in the CompileType. Thus, no
  // approach will be able to distinguish the two types, and so we fail the
  // comparison in all cases.
  if (IsNone() || !other.IsInstantiated()) {
    return false;
  }
  if (is_nullable() && !Instance::NullIsAssignableTo(other)) {
    return false;
  }
  return ToAbstractType()->IsSubtypeOf(other, Heap::kOld);
}

IsBool()

bool dart::CompileType::IsBool ( )

inline

Definition at line 233 of file compile_type.h.

{ return !is_nullable() && IsNullableBool(); }

IsDouble()

bool dart::CompileType::IsDouble ( )

inline

Definition at line 230 of file compile_type.h.

{ return !is_nullable() && IsNullableDouble(); }

IsEqualTo()

bool dart::CompileType::IsEqualTo ( CompileType *  other )

inline

Definition at line 214 of file compile_type.h.

                                     {
    return (can_be_null_ == other->can_be_null_) &&
           (can_be_sentinel_ == other->can_be_sentinel_) &&
           (ToNullableCid() == other->ToNullableCid()) &&
           (compiler::IsEqualType(*ToAbstractType(), *other->ToAbstractType()));
  }

IsInstanceOf()

bool dart::CompileType::IsInstanceOf

(

const AbstractType &

other

)

Definition at line 908 of file type_propagator.cc.

                                                        {
  if (other.IsTopTypeForInstanceOf()) {
    return true;
  }
  if (IsNone() || !other.IsInstantiated()) {
    return false;
  }
  if (is_nullable() && !other.IsNullable()) {
    return false;
  }
  return ToAbstractType()->IsSubtypeOf(other, Heap::kOld);
}

IsInt()

bool dart::CompileType::IsInt ( )

inline

Definition at line 227 of file compile_type.h.

{ return !is_nullable() && IsNullableInt(); }

IsNone()

bool dart::CompileType::IsNone ( ) const

inline

Definition at line 221 of file compile_type.h.

{ return (cid_ == kIllegalCid) && (type_ == nullptr); }

IsNull()

bool dart::CompileType::IsNull

(

)

Definition at line 844 of file type_propagator.cc.

                         {
  return (ToCid() == kNullCid);
}

IsNullableBool()

bool dart::CompileType::IsNullableBool ( )

inline

Definition at line 269 of file compile_type.h.

                        {
    if (cid_ == kBoolCid) {
      return true;
    }
    if ((cid_ == kIllegalCid) || (cid_ == kDynamicCid)) {
      return type_ != nullptr && compiler::IsBoolType(*type_);
    }
    return false;
  }

IsNullableDouble()

bool dart::CompileType::IsNullableDouble ( )

inline

Definition at line 258 of file compile_type.h.

                          {
    if (cid_ == kDoubleCid) {
      return true;
    }
    if ((cid_ == kIllegalCid) || (cid_ == kDynamicCid)) {
      return type_ != nullptr && compiler::IsDoubleType(*type_);
    }
    return false;
  }

IsNullableInt()

bool dart::CompileType::IsNullableInt ( )

inline

Definition at line 236 of file compile_type.h.

                       {
    if (cid_ == kSmiCid || cid_ == kMintCid) {
      return true;
    }
    if (cid_ == kIllegalCid || cid_ == kDynamicCid) {
      return type_ != nullptr && compiler::IsSubtypeOfInt(*type_);
    }
    return false;
  }

IsNullableSmi()

bool dart::CompileType::IsNullableSmi ( )

inline

Definition at line 247 of file compile_type.h.

                       {
    if (cid_ == kSmiCid) {
      return true;
    }
    if (cid_ == kIllegalCid || cid_ == kDynamicCid) {
      return type_ != nullptr && compiler::IsSmiType(*type_);
    }
    return false;
  }

IsObject()

bool dart::CompileType::IsObject

(

)

const

Definition at line 777 of file type_propagator.cc.

                                 {
  if (is_nullable()) return false;
  if (cid_ != kIllegalCid && cid_ != kDynamicCid) return false;
  return type_ != nullptr && type_->IsObjectType();
}

IsSubtypeOf()

bool dart::CompileType::IsSubtypeOf

(

const AbstractType &

other

)

Definition at line 870 of file type_propagator.cc.

                                                       {
  if (other.IsTopTypeForSubtyping()) {
    return true;
  }
 
  if (IsNone()) {
    return false;
  }
 
  return ToAbstractType()->IsSubtypeOf(other, Heap::kOld);
}

None()

static CompileType dart::CompileType::None ( )

inlinestatic

Definition at line 155 of file compile_type.h.

                            {
    return CompileType(kCanBeNull, kCanBeSentinel, kIllegalCid, nullptr);
  }

Null()

CompileType dart::CompileType::Null ( )

static

Definition at line 724 of file type_propagator.cc.

                              {
  return CompileType(kCanBeNull, kCannotBeSentinel, kNullCid,
                     &Type::ZoneHandle(Type::NullType()));
}

NullableDouble()

CompileType dart::CompileType::NullableDouble ( )

static

Definition at line 762 of file type_propagator.cc.

                                        {
  return FromAbstractType(Type::ZoneHandle(Type::NullableDouble()), kCanBeNull,
                          kCannotBeSentinel);
}

NullableInt()

CompileType dart::CompileType::NullableInt ( )

static

Definition at line 747 of file type_propagator.cc.

                                     {
  return FromAbstractType(Type::ZoneHandle(Type::NullableIntType()), kCanBeNull,
                          kCannotBeSentinel);
}

NullableMint()

static CompileType dart::CompileType::NullableMint ( )

inlinestatic

Definition at line 188 of file compile_type.h.

                                    {
    return CompileType(kCanBeNull, kCannotBeSentinel, kMintCid, nullptr);
  }

NullableSmi()

static CompileType dart::CompileType::NullableSmi ( )

inlinestatic

Definition at line 183 of file compile_type.h.

                                   {
    return CompileType(kCanBeNull, kCannotBeSentinel, kSmiCid, nullptr);
  }

Object()

CompileType dart::CompileType::Object ( )

static

Definition at line 772 of file type_propagator.cc.

                                {
  return FromAbstractType(Type::ZoneHandle(Type::ObjectType()), kCannotBeNull,
                          kCannotBeSentinel);
}

operator=()

CompileType & dart::CompileType::operator= ( const CompileType &  other )

inline

Definition at line 67 of file compile_type.h.

                                                   {
    // This intentionally does not change the owner of this type.
    can_be_null_ = other.can_be_null_;
    can_be_sentinel_ = other.can_be_sentinel_;
    cid_ = other.cid_;
    type_ = other.type_;
    return *this;
  }

owner()

Definition * dart::CompileType::owner ( ) const

inline

Definition at line 304 of file compile_type.h.

{ return owner_; }

PrintTo() [1/2]

void dart::CompileType::PrintTo

(

BaseTextBuffer *

f

)

const

Definition at line 1042 of file type_propagator.cc.

                                                 {
  const char* type_name = "?";
  if (IsNone()) {
    f->AddString("T{}");
    return;
  } else if ((cid_ != kIllegalCid) && (cid_ != kDynamicCid)) {
    const Class& cls =
        Class::Handle(IsolateGroup::Current()->class_table()->At(cid_));
    type_name = cls.ScrubbedNameCString();
  } else if (type_ != nullptr) {
    type_name = type_->IsDynamicType() ? "*" : type_->ScrubbedNameCString();
  } else if (!is_nullable()) {
    type_name = "!null";
  }
 
  f->Printf("T{%s%s%s}", type_name, can_be_null_ ? "?" : "",
            can_be_sentinel_ ? "~" : "");
}

PrintTo() [2/2]

void dart::CompileType::PrintTo

(

JSONWriter *

writer

)

const

Definition at line 1018 of file type_propagator.cc.

                                                  {
  if (IsNone()) {
    return;
  }
 
  if (cid_ != kIllegalCid && cid_ != kDynamicCid) {
    const Class& cls =
        Class::Handle(IsolateGroup::Current()->class_table()->At(cid_));
    writer->PrintPropertyStr("c", String::Handle(cls.ScrubbedName()));
  }
 
  if (type_ != nullptr && !type_->IsDynamicType()) {
    writer->PrintPropertyStr("t", String::Handle(type_->ScrubbedName()));
  }
 
  if (can_be_null_) {
    writer->PrintPropertyBool("n", true);
  }
 
  if (can_be_sentinel_) {
    writer->PrintPropertyBool("s", true);
  }
}

set_owner()

void dart::CompileType::set_owner ( Definition *  owner )

inline

Definition at line 303 of file compile_type.h.

{ owner_ = owner; }

Smi()

CompileType dart::CompileType::Smi ( )

static

Definition at line 752 of file type_propagator.cc.

                             {
  return CompileType(kCannotBeNull, kCannotBeSentinel, kSmiCid,
                     &Type::ZoneHandle(Type::SmiType()));
}

Specialize()

bool dart::CompileType::Specialize

(

GrowableArray< intptr_t > *

class_ids

)

Definition at line 921 of file type_propagator.cc.

                                                               {
  ToNullableCid();
  if (cid_ != kDynamicCid) {
    class_ids->Add(cid_);
    return true;
  }
  if (type_ != nullptr && type_->type_class_id() != kIllegalCid) {
    const Class& type_class = Class::Handle(type_->type_class());
    if (!CHA::ConcreteSubclasses(type_class, class_ids)) return false;
    if (can_be_null_) {
      class_ids->Add(kNullCid);
    }
    if (can_be_sentinel_) {
      class_ids->Add(kSentinelCid);
    }
  }
  return false;
}

String()

CompileType dart::CompileType::String ( )

static

Definition at line 767 of file type_propagator.cc.

                                {
  return FromAbstractType(Type::ZoneHandle(Type::StringType()), kCannotBeNull,
                          kCannotBeSentinel);
}

ToAbstractType()

const AbstractType * dart::CompileType::ToAbstractType

(

)

Definition at line 848 of file type_propagator.cc.

                                                {
  if (type_ == nullptr) {
    // Type propagation has not run. Return dynamic-type.
    if (cid_ == kIllegalCid) {
      return &Object::dynamic_type();
    }
 
    // VM-internal objects don't have a compile-type. Return dynamic-type
    // in this case.
    if (IsInternalOnlyClassId(cid_) || cid_ == kTypeArgumentsCid) {
      type_ = &Object::dynamic_type();
      return type_;
    }
 
    auto IG = IsolateGroup::Current();
    const Class& type_class = Class::Handle(IG->class_table()->At(cid_));
    type_ = &AbstractType::ZoneHandle(type_class.RareType());
  }
 
  return type_;
}

ToCid()

intptr_t dart::CompileType::ToCid

(

)

Definition at line 783 of file type_propagator.cc.

                            {
  if (cid_ == kIllegalCid) {
    // Make sure to initialize cid_ for Null type to consistently return
    // kNullCid.
    if ((type_ != nullptr) && type_->IsNullType()) {
      cid_ = kNullCid;
    }
    // Same for sentinel.
    if ((type_ != nullptr) && type_->IsSentinelType()) {
      cid_ = kSentinelCid;
    }
  }
 
  if ((cid_ == kDynamicCid) || (can_be_null_ && (cid_ != kNullCid)) ||
      (can_be_sentinel_ && (cid_ != kSentinelCid))) {
    return kDynamicCid;
  }
 
  return ToNullableCid();
}

ToCString()

const char * dart::CompileType::ToCString

(

)

const

Definition at line 1061 of file type_propagator.cc.

                                         {
  char buffer[1024];
  BufferFormatter f(buffer, sizeof(buffer));
  PrintTo(&f);
  return Thread::Current()->zone()->MakeCopyOfString(buffer);
}

ToNullableCid()

intptr_t dart::CompileType::ToNullableCid

(

)

Definition at line 804 of file type_propagator.cc.

                                    {
  if (cid_ == kIllegalCid) {
    if (type_ == nullptr) {
      // Type propagation is turned off or has not yet run.
      return kDynamicCid;
    } else if (type_->IsVoidType()) {
      cid_ = kDynamicCid;
    } else if (type_->IsNullType()) {
      cid_ = kNullCid;
    } else if (type_->IsSentinelType()) {
      cid_ = kSentinelCid;
    } else if (type_->IsFunctionType() || type_->IsDartFunctionType()) {
      cid_ = kClosureCid;
    } else if (type_->IsRecordType() || type_->IsDartRecordType()) {
      cid_ = kRecordCid;
    } else if (type_->type_class_id() != kIllegalCid) {
      const Class& type_class = Class::Handle(type_->type_class());
      intptr_t implementation_cid = kIllegalCid;
      if (CHA::HasSingleConcreteImplementation(type_class,
                                               &implementation_cid)) {
        cid_ = implementation_cid;
      } else {
        cid_ = kDynamicCid;
      }
    } else {
      cid_ = kDynamicCid;
    }
  }
 
  if (can_be_sentinel_ && (cid_ != kSentinelCid)) {
    return kDynamicCid;
  }
 
  return cid_;
}

Union()

void dart::CompileType::Union

(

CompileType *

other

)

Definition at line 557 of file type_propagator.cc.

                                          {
  if (other->IsNone()) {
    return;
  }
 
  if (IsNone()) {
    *this = *other;
    return;
  }
 
  can_be_null_ = can_be_null_ || other->can_be_null_;
  can_be_sentinel_ = can_be_sentinel_ || other->can_be_sentinel_;
 
  ToNullableCid();  // Ensure cid_ is set.
  if ((cid_ == kNullCid) || (cid_ == kSentinelCid)) {
    cid_ = other->cid_;
    type_ = other->type_;
    return;
  }
 
  other->ToNullableCid();  // Ensure other->cid_ is set.
  if ((other->cid_ == kNullCid) || (other->cid_ == kSentinelCid)) {
    return;
  }
 
  const AbstractType* abstract_type = ToAbstractType();
  if (cid_ != other->cid_) {
    cid_ = kDynamicCid;
  }
 
  const AbstractType* other_abstract_type = other->ToAbstractType();
  if (abstract_type->IsSubtypeOf(*other_abstract_type, Heap::kOld)) {
    type_ = other_abstract_type;
    return;
  } else if (other_abstract_type->IsSubtypeOf(*abstract_type, Heap::kOld)) {
    return;  // Nothing to do.
  }
 
  // Climb up the hierarchy to find a suitable supertype. Note that interface
  // types are not considered, making the union potentially non-commutative
  if (abstract_type->IsInstantiated() && !abstract_type->IsDynamicType() &&
      !abstract_type->IsFunctionType() && !abstract_type->IsRecordType()) {
    Class& cls = Class::Handle(abstract_type->type_class());
    for (; !cls.IsNull() && !cls.IsGeneric(); cls = cls.SuperClass()) {
      type_ = &AbstractType::ZoneHandle(cls.RareType());
      if (other_abstract_type->IsSubtypeOf(*type_, Heap::kOld)) {
        // Found suitable supertype: keep type_ only.
        cid_ = kDynamicCid;
        return;
      }
    }
  }
 
  // Can't unify.
  type_ = &Object::dynamic_type();
}

Write()

void dart::CompileType::Write

(

FlowGraphSerializer *

s

)

const

Definition at line 515 of file il_serializer.cc.

                                                    {
  s->Write<bool>(can_be_null_);
  s->Write<bool>(can_be_sentinel_);
  s->Write<classid_t>(cid_);
  if (type_ == nullptr) {
    s->Write<bool>(false);
  } else {
    s->Write<bool>(true);
    s->Write<const AbstractType&>(*type_);
  }
}

Member Data Documentation

kCanBeNull

constexpr bool dart::CompileType::kCanBeNull = true

staticconstexpr

Definition at line 45 of file compile_type.h.

kCanBeSentinel

constexpr bool dart::CompileType::kCanBeSentinel = true

staticconstexpr

Definition at line 48 of file compile_type.h.

kCannotBeNull

constexpr bool dart::CompileType::kCannotBeNull = false

staticconstexpr

Definition at line 46 of file compile_type.h.

kCannotBeSentinel

constexpr bool dart::CompileType::kCannotBeSentinel = false

staticconstexpr

Definition at line 49 of file compile_type.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/compiler/backend/compile_type.h
• third_party/dart-lang/sdk/runtime/vm/compiler/backend/il_serializer.cc
• third_party/dart-lang/sdk/runtime/vm/compiler/backend/type_propagator.cc