From 89fdaf5ad853c3d55060b9929027946833aee77a Mon Sep 17 00:00:00 2001 From: Iain Buclaw Date: Wed, 3 Jun 2020 15:26:25 +0200 Subject: [PATCH] d: Use new isTypeXxxx helpers where possible. gcc/d/ChangeLog: * d-builtins.cc (d_eval_constant_expression): Use isTypeXxxx helpers instead of explicit casts. (d_build_builtins_module): Likewise. * d-codegen.cc (get_array_length): Likewise. (identity_compare_p): Likewise. (lower_struct_comparison): Likewise. (build_array_from_val): Likewise. (array_bounds_check): Likewise. (get_function_type): Likewise. (d_build_call): Likewise. * d-compiler.cc (Compiler::paintAsType): Likewise. * d-convert.cc (convert_expr): Likewise. (convert_for_assignment): Likewise. * d-lang.cc (d_classify_record): Likewise. (d_build_eh_runtime_type): Likewise. * decl.cc (DeclVisitor::visit): Likewise. * expr.cc (ExprVisitor::needs_postblit): Likewise. (ExprVisitor::needs_dtor): Likewise. (ExprVisitor::visit): Likewise. * imports.cc (ImportVisitor::visit): Likewise. * typeinfo.cc (get_typeinfo_kind): Likewise. (TypeInfoVisitor::visit): Likewise. (TypeDeclInfoVisitor::visit): Likewise. * types.cc (merge_aggregate_types): Likewise. (TypeVisitor::visit): Likewise. --- gcc/d/d-builtins.cc | 15 +++++----- gcc/d/d-codegen.cc | 24 ++++++--------- gcc/d/d-compiler.cc | 4 +-- gcc/d/d-convert.cc | 4 +-- gcc/d/d-lang.cc | 13 ++++----- gcc/d/decl.cc | 16 ++++------ gcc/d/expr.cc | 71 ++++++++++++++++++--------------------------- gcc/d/imports.cc | 6 ++-- gcc/d/typeinfo.cc | 43 ++++++++++----------------- gcc/d/types.cc | 6 ++-- 10 files changed, 82 insertions(+), 120 deletions(-) diff --git a/gcc/d/d-builtins.cc b/gcc/d/d-builtins.cc index 91e3173e670..f1bdcb9fafd 100644 --- a/gcc/d/d-builtins.cc +++ b/gcc/d/d-builtins.cc @@ -388,7 +388,7 @@ d_eval_constant_expression (tree cst) } Expression *e = ArrayLiteralExp::create (Loc (), elements); - e->type = ((TypeVector *) type)->basetype; + e->type = type->isTypeVector ()->basetype; return VectorExp::create (Loc (), e, type); } @@ -517,8 +517,8 @@ d_build_builtins_module (Module *m) for (size_t i = 0; vec_safe_iterate (gcc_builtins_functions, i, &decl); ++i) { const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); - TypeFunction *tf - = (TypeFunction *) build_frontend_type (TREE_TYPE (decl)); + Type *t = build_frontend_type (TREE_TYPE (decl)); + TypeFunction *tf = t ? t->isTypeFunction () : NULL; /* Cannot create built-in function type for DECL. */ if (!tf) @@ -601,14 +601,13 @@ d_build_builtins_module (Module *m) /* Expose target-specific va_list type. */ Type *tvalist = target.va_listType (Loc (), NULL); - StructDeclaration *sd = (tvalist->ty == Tstruct) - ? ((TypeStruct *) tvalist)->sym : NULL; - if (sd == NULL || !sd->isAnonymous ()) + TypeStruct *ts = tvalist->isTypeStruct (); + if (ts == NULL || !ts->sym->isAnonymous ()) members->push (build_alias_declaration ("__builtin_va_list", tvalist)); else { - sd->ident = Identifier::idPool ("__builtin_va_list"); - members->push (sd); + ts->sym->ident = Identifier::idPool ("__builtin_va_list"); + members->push (ts->sym); } /* Expose target-specific integer types to the builtins module. */ diff --git a/gcc/d/d-codegen.cc b/gcc/d/d-codegen.cc index 83e757d5a38..1bf74e1f223 100644 --- a/gcc/d/d-codegen.cc +++ b/gcc/d/d-codegen.cc @@ -319,7 +319,7 @@ get_array_length (tree exp, Type *type) switch (tb->ty) { case Tsarray: - return size_int (((TypeSArray *) tb)->dim->toUInteger ()); + return size_int (tb->isTypeSArray ()->dim->toUInteger ()); case Tarray: return d_array_length (exp); @@ -812,9 +812,8 @@ identity_compare_p (StructDeclaration *sd) Type *tb = vd->type->toBasetype (); /* Check inner data structures. */ - if (tb->ty == Tstruct) + if (TypeStruct *ts = tb->isTypeStruct ()) { - TypeStruct *ts = (TypeStruct *) tb; if (!identity_compare_p (ts->sym)) return false; } @@ -897,11 +896,10 @@ lower_struct_comparison (tree_code code, StructDeclaration *sd, tree t2ref = component_ref (t2, sfield); tree tcmp; - if (type->ty == Tstruct) + if (TypeStruct *ts = type->isTypeStruct ()) { /* Compare inner data structures. */ - StructDeclaration *decl = ((TypeStruct *) type)->sym; - tcmp = lower_struct_comparison (code, decl, t1ref, t2ref); + tcmp = lower_struct_comparison (code, ts->sym, t1ref, t2ref); } else if (type->ty != Tvector && type->isintegral ()) { @@ -1680,15 +1678,13 @@ build_array_set (tree ptr, tree length, tree value) tree build_array_from_val (Type *type, tree val) { - gcc_assert (type->ty == Tsarray); - tree etype = build_ctype (type->nextOf ()); /* Initializing a multidimensional array. */ if (TREE_CODE (etype) == ARRAY_TYPE && TREE_TYPE (val) != etype) val = build_array_from_val (type->nextOf (), val); - size_t dims = ((TypeSArray *) type)->dim->toInteger (); + size_t dims = type->isTypeSArray ()->dim->toInteger (); vec *elms = NULL; vec_safe_reserve (elms, dims); @@ -1762,8 +1758,7 @@ array_bounds_check (void) fd = d_function_chain->function; if (fd && fd->type->ty == Tfunction) { - TypeFunction *tf = (TypeFunction *) fd->type; - if (tf->trust == TRUSTsafe) + if (fd->type->isTypeFunction ()->trust == TRUSTsafe) return true; } return false; @@ -1783,9 +1778,9 @@ get_function_type (Type *t) if (t->ty == Tpointer) t = t->nextOf ()->toBasetype (); if (t->ty == Tfunction) - tf = (TypeFunction *) t; + tf = t->isTypeFunction (); else if (t->ty == Tdelegate) - tf = (TypeFunction *) ((TypeDelegate *) t)->next; + tf = t->isTypeDelegate ()->next->isTypeFunction (); return tf; } @@ -1916,8 +1911,7 @@ d_build_call (TypeFunction *tf, tree callable, tree object, if (TREE_ADDRESSABLE (TREE_TYPE (targ))) { Type *t = arg->type->toBasetype (); - gcc_assert (t->ty == Tstruct); - StructDeclaration *sd = ((TypeStruct *) t)->sym; + StructDeclaration *sd = t->isTypeStruct ()->sym; /* Nested structs also have ADDRESSABLE set, but if the type has neither a copy constructor nor a destructor available, then we diff --git a/gcc/d/d-compiler.cc b/gcc/d/d-compiler.cc index a8adb983d06..75ca15737d9 100644 --- a/gcc/d/d-compiler.cc +++ b/gcc/d/d-compiler.cc @@ -111,7 +111,7 @@ Compiler::paintAsType (UnionExp *, Expression *expr, Type *type) } /* Build vector type. */ - int nunits = ((TypeSArray *) expr->type)->dim->toUInteger (); + int nunits = expr->type->isTypeSArray ()->dim->toUInteger (); Type *telem = expr->type->nextOf (); tree vectype = build_vector_type (build_ctype (telem), nunits); @@ -127,7 +127,7 @@ Compiler::paintAsType (UnionExp *, Expression *expr, Type *type) { /* Interpret value as a vector of the same size, then return the array literal. */ - int nunits = ((TypeSArray *) type)->dim->toUInteger (); + int nunits = type->isTypeSArray ()->dim->toUInteger (); Type *elem = type->nextOf (); tree vectype = build_vector_type (build_ctype (elem), nunits); diff --git a/gcc/d/d-convert.cc b/gcc/d/d-convert.cc index f93405ed956..80101f17b1d 100644 --- a/gcc/d/d-convert.cc +++ b/gcc/d/d-convert.cc @@ -467,7 +467,7 @@ convert_expr (tree exp, Type *etype, Type *totype) } else if (tbtype->ty == Tarray) { - dinteger_t dim = ((TypeSArray *) ebtype)->dim->toInteger (); + dinteger_t dim = ebtype->isTypeSArray ()->dim->toInteger (); dinteger_t esize = ebtype->nextOf ()->size (); dinteger_t tsize = tbtype->nextOf ()->size (); @@ -616,7 +616,7 @@ convert_for_assignment (tree expr, Type *etype, Type *totype) if (same_type_p (telem, ebtype)) { - TypeSArray *sa_type = (TypeSArray *) tbtype; + TypeSArray *sa_type = tbtype->isTypeSArray (); uinteger_t count = sa_type->dim->toUInteger (); tree ctor = build_constructor (build_ctype (totype), NULL); diff --git a/gcc/d/d-lang.cc b/gcc/d/d-lang.cc index badd67f5a8f..5266a6550dc 100644 --- a/gcc/d/d-lang.cc +++ b/gcc/d/d-lang.cc @@ -1672,11 +1672,10 @@ static classify_record d_classify_record (tree type) { Type *t = TYPE_LANG_FRONTEND (type); + TypeClass *tc = t ? t->isTypeClass () : NULL; - if (t && t->ty == Tclass) + if (tc != NULL) { - TypeClass *tc = (TypeClass *) t; - /* extern(C++) interfaces get emitted as classes. */ if (tc->sym->isInterfaceDeclaration () && !tc->sym->isCPPinterface ()) @@ -1814,12 +1813,10 @@ static tree d_build_eh_runtime_type (tree type) { Type *t = TYPE_LANG_FRONTEND (type); + gcc_assert (t != NULL); + t = t->toBasetype (); - if (t != NULL) - t = t->toBasetype (); - - gcc_assert (t != NULL && t->ty == Tclass); - ClassDeclaration *cd = ((TypeClass *) t)->sym; + ClassDeclaration *cd = t->isTypeClass ()->sym; tree decl; if (cd->isCPPclass ()) diff --git a/gcc/d/decl.cc b/gcc/d/decl.cc index 84aa42c139b..05868631eed 100644 --- a/gcc/d/decl.cc +++ b/gcc/d/decl.cc @@ -313,9 +313,9 @@ public: TemplateInstance *ti = NULL; if (tb->ty == Tstruct) - ti = ((TypeStruct *) tb)->sym->isInstantiated (); + ti = tb->isTypeStruct ()->sym->isInstantiated (); else if (tb->ty == Tclass) - ti = ((TypeClass *) tb)->sym->isInstantiated (); + ti = tb->isTypeClass ()->sym->isInstantiated (); /* Return type is instantiated from this template declaration, walk over all members of the instance. */ @@ -620,7 +620,7 @@ public: if (have_typeinfo_p (Type::dtypeinfo)) create_typeinfo (d->type, NULL); - TypeEnum *tc = (TypeEnum *) d->type; + TypeEnum *tc = d->type->isTypeEnum (); if (tc->sym->members && !d->type->isZeroInit ()) { /* Generate static initializer. */ @@ -717,11 +717,8 @@ public: } else { - if (d->type->ty == Tstruct) - { - StructDeclaration *sd = ((TypeStruct *) d->type)->sym; - DECL_INITIAL (decl) = layout_struct_initializer (sd); - } + if (TypeStruct *ts = d->type->isTypeStruct ()) + DECL_INITIAL (decl) = layout_struct_initializer (ts->sym); else { Expression *e = d->type->defaultInitLiteral (d->loc); @@ -813,9 +810,8 @@ public: return; /* Check if any errors occurred when running semantic. */ - if (d->type->ty == Tfunction) + if (TypeFunction *tf = d->type->isTypeFunction ()) { - TypeFunction *tf = (TypeFunction *) d->type; if (tf->next == NULL || tf->next->ty == Terror) return; } diff --git a/gcc/d/expr.cc b/gcc/d/expr.cc index 1940480f9c4..9c80db15552 100644 --- a/gcc/d/expr.cc +++ b/gcc/d/expr.cc @@ -62,10 +62,9 @@ class ExprVisitor : public Visitor { t = t->baseElemOf (); - if (t->ty == Tstruct) + if (TypeStruct *ts = t->isTypeStruct ()) { - StructDeclaration *sd = ((TypeStruct *) t)->sym; - if (sd->postblit) + if (ts->sym->postblit) return true; } @@ -78,10 +77,9 @@ class ExprVisitor : public Visitor { t = t->baseElemOf (); - if (t->ty == Tstruct) + if (TypeStruct *ts = t->isTypeStruct ()) { - StructDeclaration *sd = ((TypeStruct *) t)->sym; - if (sd->dtor) + if (ts->sym->dtor) return true; } @@ -298,17 +296,16 @@ public: this->result_ = build_boolop (TRUTH_ORIF_EXPR, req, ieq); } } - else if (tb1->ty == Tstruct) + else if (TypeStruct *ts = tb1->isTypeStruct ()) { /* For struct objects, identity is defined as bits in operands being identical also. Alignment holes in structs are ignored. */ - StructDeclaration *sd = ((TypeStruct *) tb1)->sym; tree t1 = build_expr (e->e1); tree t2 = build_expr (e->e2); gcc_assert (same_type_p (tb1, tb2)); - this->result_ = build_struct_comparison (code, sd, t1, t2); + this->result_ = build_struct_comparison (code, ts->sym, t1, t2); } else { @@ -345,7 +342,7 @@ public: Or when generating a NE expression: e1.length != e2.length || memcmp(e1.ptr, e2.ptr, size) != 0; */ if ((t1elem->isintegral () || t1elem->ty == Tvoid - || (t1elem->ty == Tstruct && !((TypeStruct *)t1elem)->sym->xeq)) + || (t1elem->ty == Tstruct && !t1elem->isTypeStruct ()->sym->xeq)) && t1elem->ty == t2elem->ty) { tree t1 = d_array_convert (e->e1); @@ -367,7 +364,7 @@ public: /* Compare arrays using memcmp if possible, otherwise for structs, each field is compared inline. */ if (t1elem->ty != Tstruct - || identity_compare_p (((TypeStruct *) t1elem)->sym)) + || identity_compare_p (t1elem->isTypeStruct ()->sym)) { tree size = size_mult_expr (t1len, size_int (t1elem->size ())); tree tmemcmp = builtin_decl_explicit (BUILT_IN_MEMCMP); @@ -377,7 +374,7 @@ public: } else { - StructDeclaration *sd = ((TypeStruct *) t1elem)->sym; + StructDeclaration *sd = t1elem->isTypeStruct ()->sym; result = build_array_struct_comparison (code, sd, t1len, t1ptr, t2ptr); @@ -432,24 +429,22 @@ public: this->result_ = result; } } - else if (tb1->ty == Tstruct) + else if (TypeStruct *ts = tb1->isTypeStruct ()) { /* Equality for struct objects means the logical product of all equality results of the corresponding object fields. */ - StructDeclaration *sd = ((TypeStruct *) tb1)->sym; tree t1 = build_expr (e->e1); tree t2 = build_expr (e->e2); gcc_assert (same_type_p (tb1, tb2)); - this->result_ = build_struct_comparison (code, sd, t1, t2); + this->result_ = build_struct_comparison (code, ts->sym, t1, t2); } else if (tb1->ty == Taarray && tb2->ty == Taarray) { /* Use _aaEqual() for associative arrays. */ - TypeAArray *taa1 = (TypeAArray *) tb1; tree result = build_libcall (LIBCALL_AAEQUAL, e->type, 3, - build_typeinfo (e->loc, taa1), + build_typeinfo (e->loc, tb1), build_expr (e->e1), build_expr (e->e2)); @@ -477,9 +472,7 @@ public: void visit (InExp *e) { Type *tb2 = e->e2->type->toBasetype (); - gcc_assert (tb2->ty == Taarray); - - Type *tkey = ((TypeAArray *) tb2)->index->toBasetype (); + Type *tkey = tb2->isTypeAArray ()->index->toBasetype (); tree key = convert_expr (build_expr (e->e1), e->e1->type, tkey); /* Build a call to _aaInX(). */ @@ -1031,7 +1024,7 @@ public: tree t1 = build_expr (e->e1); tree t2 = convert_for_assignment (build_expr (e->e2), e->e2->type, e->e1->type); - StructDeclaration *sd = ((TypeStruct *) tb1)->sym; + StructDeclaration *sd = tb1->isTypeStruct ()->sym; /* Look for struct = 0. */ if (e->e2->op == TOKint64) @@ -1193,7 +1186,7 @@ public: if (tb1->ty == Taarray) { /* Get the key for the associative array. */ - Type *tkey = ((TypeAArray *) tb1)->index->toBasetype (); + Type *tkey = tb1->isTypeAArray ()->index->toBasetype (); tree key = convert_expr (build_expr (e->e2), e->e2->type, tkey); libcall_fn libcall; tree tinfo, ptr; @@ -1476,10 +1469,9 @@ public: Type *telem = tb1->nextOf ()->baseElemOf (); tree ti = null_pointer_node; - if (telem->ty == Tstruct) + if (TypeStruct *ts = telem->isTypeStruct ()) { /* Might need to run destructor on array contents. */ - TypeStruct *ts = (TypeStruct *) telem; if (ts->sym->dtor) ti = build_typeinfo (e->loc, tb1->nextOf ()); } @@ -1493,11 +1485,10 @@ public: /* For pointers to a struct instance, if the struct has overloaded operator delete, then that operator is called. */ t1 = build_address (t1); - Type *tnext = ((TypePointer *)tb1)->next->toBasetype (); + Type *tnext = tb1->isTypePointer ()->next->toBasetype (); - if (tnext->ty == Tstruct) + if (TypeStruct *ts = tnext->isTypeStruct ()) { - TypeStruct *ts = (TypeStruct *)tnext; if (ts->sym->dtor) { tree ti = build_typeinfo (e->loc, tnext); @@ -1527,7 +1518,7 @@ public: if (e->e1->type->toBasetype ()->ty == Taarray) { Type *tb = e->e1->type->toBasetype (); - Type *tkey = ((TypeAArray *) tb)->index->toBasetype (); + Type *tkey = tb->isTypeAArray ()->index->toBasetype (); tree index = convert_expr (build_expr (e->e2), e->e2->type, tkey); this->result_ = build_libcall (LIBCALL_AADELX, Type::tbool, 3, @@ -1623,7 +1614,7 @@ public: allocated in memory because its address is taken. */ if (tnext && tnext->ty == Tstruct) { - StructDeclaration *sd = ((TypeStruct *) tnext)->sym; + StructDeclaration *sd = tnext->isTypeStruct ()->sym; for (size_t i = 0; i < sd->fields.length; i++) { @@ -1998,7 +1989,7 @@ public: } else if (tb1->ty == Tpointer && tb1->nextOf ()->ty == Tstruct) { - StructDeclaration *sd = ((TypeStruct *) tb1->nextOf ())->sym; + StructDeclaration *sd = tb1->nextOf ()->isTypeStruct ()->sym; if (sd->inv != NULL) { Expressions args; @@ -2089,7 +2080,7 @@ public: ci = indirect_ref (ptr_type_node, ci); /* Add extra indirection for interfaces. */ - if (((TypeClass *) type)->sym->isInterfaceDeclaration ()) + if (type->isTypeClass ()->sym->isInterfaceDeclaration ()) ci = indirect_ref (ptr_type_node, ci); this->result_ = build_nop (build_ctype (e->type), ci); @@ -2288,9 +2279,8 @@ public: { /* Allocating a new class. */ tb = e->newtype->toBasetype (); - gcc_assert (tb->ty == Tclass); - ClassDeclaration *cd = ((TypeClass *) tb)->sym; + ClassDeclaration *cd = tb->isTypeClass ()->sym; tree type = build_ctype (tb); tree setup_exp = NULL_TREE; tree new_call; @@ -2368,10 +2358,9 @@ public: { /* Allocating memory for a new struct. */ Type *htype = e->newtype->toBasetype (); - gcc_assert (htype->ty == Tstruct); gcc_assert (!e->onstack); - TypeStruct *stype = (TypeStruct *) htype; + TypeStruct *stype = htype->isTypeStruct (); StructDeclaration *sd = stype->sym; tree new_call; @@ -2443,8 +2432,7 @@ public: { /* Allocating memory for a new D array. */ tb = e->newtype->toBasetype (); - gcc_assert (tb->ty == Tarray); - TypeDArray *tarray = (TypeDArray *) tb; + TypeDArray *tarray = tb->isTypeDArray (); gcc_assert (!e->allocator); gcc_assert (e->arguments && e->arguments->length >= 1); @@ -2511,7 +2499,7 @@ public: else if (tb->ty == Tpointer) { /* Allocating memory for a new pointer. */ - TypePointer *tpointer = (TypePointer *) tb; + TypePointer *tpointer = tb->isTypePointer (); if (tpointer->next->size () == 0) { @@ -2666,7 +2654,7 @@ public: /* Implicitly convert void[n] to ubyte[n]. */ if (tb->ty == Tsarray && tb->nextOf ()->toBasetype ()->ty == Tvoid) - tb = Type::tuns8->sarrayOf (((TypeSArray *) tb)->dim->toUInteger ()); + tb = Type::tuns8->sarrayOf (tb->isTypeSArray ()->dim->toUInteger ()); gcc_assert (tb->ty == Tarray || tb->ty == Tsarray || tb->ty == Tpointer); @@ -2781,10 +2769,9 @@ public: { /* Want the mutable type for typeinfo reference. */ Type *tb = e->type->toBasetype ()->mutableOf (); - gcc_assert (tb->ty == Taarray); /* Handle empty assoc array literals. */ - TypeAArray *ta = (TypeAArray *) tb; + TypeAArray *ta = tb->isTypeAArray (); if (e->keys->length == 0) { this->result_ = build_constructor (build_ctype (ta), NULL); @@ -3018,7 +3005,7 @@ public: interface offset to symbol. */ if (this->constp_) { - TypeClass *tc = (TypeClass *) e->type; + TypeClass *tc = e->type->toBasetype ()->isTypeClass (); InterfaceDeclaration *to = tc->sym->isInterfaceDeclaration (); if (to != NULL) diff --git a/gcc/d/imports.cc b/gcc/d/imports.cc index 2e3eb7408b7..e6e696ab325 100644 --- a/gcc/d/imports.cc +++ b/gcc/d/imports.cc @@ -131,11 +131,11 @@ public: if (type != NULL) { if (type->ty == Tenum) - dsym = ((TypeEnum *) type)->sym; + dsym = type->isTypeEnum ()->sym; else if (type->ty == Tstruct) - dsym = ((TypeStruct *) type)->sym; + dsym = type->isTypeStruct ()->sym; else if (type->ty == Tclass) - dsym = ((TypeClass *) type)->sym; + dsym = type->isTypeClass ()->sym; } } diff --git a/gcc/d/typeinfo.cc b/gcc/d/typeinfo.cc index 8249fa7c2e8..73443eaed50 100644 --- a/gcc/d/typeinfo.cc +++ b/gcc/d/typeinfo.cc @@ -140,7 +140,7 @@ get_typeinfo_kind (Type *type) return TK_TYPELIST_TYPE; case Tclass: - if (((TypeClass *) type)->sym->isInterfaceDeclaration ()) + if (type->isTypeClass ()->sym->isInterfaceDeclaration ()) return TK_INTERFACE_TYPE; else return TK_CLASSINFO_TYPE; @@ -619,8 +619,7 @@ public: void visit (TypeInfoEnumDeclaration *d) { - gcc_assert (d->tinfo->ty == Tenum); - TypeEnum *ti = (TypeEnum *) d->tinfo; + TypeEnum *ti = d->tinfo->isTypeEnum (); EnumDeclaration *ed = ti->sym; /* The vtable for TypeInfo_Enum. */ @@ -652,8 +651,7 @@ public: void visit (TypeInfoPointerDeclaration *d) { - gcc_assert (d->tinfo->ty == Tpointer); - TypePointer *ti = (TypePointer *) d->tinfo; + TypePointer *ti = d->tinfo->isTypePointer (); /* The vtable for TypeInfo_Pointer. */ this->layout_base (Type::typeinfopointer); @@ -669,8 +667,7 @@ public: void visit (TypeInfoArrayDeclaration *d) { - gcc_assert (d->tinfo->ty == Tarray); - TypeDArray *ti = (TypeDArray *) d->tinfo; + TypeDArray *ti = d->tinfo->isTypeDArray (); /* The vtable for TypeInfo_Array. */ this->layout_base (Type::typeinfoarray); @@ -687,8 +684,7 @@ public: void visit (TypeInfoStaticArrayDeclaration *d) { - gcc_assert (d->tinfo->ty == Tsarray); - TypeSArray *ti = (TypeSArray *) d->tinfo; + TypeSArray *ti = d->tinfo->isTypeSArray (); /* The vtable for TypeInfo_StaticArray. */ this->layout_base (Type::typeinfostaticarray); @@ -708,8 +704,7 @@ public: void visit (TypeInfoAssociativeArrayDeclaration *d) { - gcc_assert (d->tinfo->ty == Taarray); - TypeAArray *ti = (TypeAArray *) d->tinfo; + TypeAArray *ti = d->tinfo->isTypeAArray (); /* The vtable for TypeInfo_AssociativeArray. */ this->layout_base (Type::typeinfoassociativearray); @@ -728,8 +723,7 @@ public: void visit (TypeInfoVectorDeclaration *d) { - gcc_assert (d->tinfo->ty == Tvector); - TypeVector *ti = (TypeVector *) d->tinfo; + TypeVector *ti = d->tinfo->isTypeVector (); /* The vtable for TypeInfo_Vector. */ this->layout_base (Type::typeinfovector); @@ -746,8 +740,8 @@ public: void visit (TypeInfoFunctionDeclaration *d) { - gcc_assert (d->tinfo->ty == Tfunction && d->tinfo->deco != NULL); - TypeFunction *ti = (TypeFunction *) d->tinfo; + TypeFunction *ti = d->tinfo->isTypeFunction (); + gcc_assert (ti->deco != NULL); /* The vtable for TypeInfo_Function. */ this->layout_base (Type::typeinfofunction); @@ -767,8 +761,8 @@ public: void visit (TypeInfoDelegateDeclaration *d) { - gcc_assert (d->tinfo->ty == Tdelegate && d->tinfo->deco != NULL); - TypeDelegate *ti = (TypeDelegate *) d->tinfo; + TypeDelegate *ti = d->tinfo->isTypeDelegate (); + gcc_assert (ti->deco != NULL); /* The vtable for TypeInfo_Delegate. */ this->layout_base (Type::typeinfodelegate); @@ -801,8 +795,7 @@ public: void visit (TypeInfoClassDeclaration *d) { - gcc_assert (d->tinfo->ty == Tclass); - TypeClass *ti = (TypeClass *) d->tinfo; + TypeClass *ti = d->tinfo->isTypeClass (); ClassDeclaration *cd = ti->sym; /* The vtable for ClassInfo. */ @@ -994,8 +987,7 @@ public: void visit (TypeInfoInterfaceDeclaration *d) { - gcc_assert (d->tinfo->ty == Tclass); - TypeClass *ti = (TypeClass *) d->tinfo; + TypeClass *ti = d->tinfo->isTypeClass (); if (!ti->sym->vclassinfo) ti->sym->vclassinfo = TypeInfoClassDeclaration::create (ti); @@ -1028,8 +1020,7 @@ public: void visit (TypeInfoStructDeclaration *d) { - gcc_assert (d->tinfo->ty == Tstruct); - TypeStruct *ti = (TypeStruct *) d->tinfo; + TypeStruct *ti = d->tinfo->isTypeStruct (); StructDeclaration *sd = ti->sym; /* The vtable for TypeInfo_Struct. */ @@ -1128,8 +1119,7 @@ public: void visit (TypeInfoTupleDeclaration *d) { - gcc_assert (d->tinfo->ty == Ttuple); - TypeTuple *ti = (TypeTuple *) d->tinfo; + TypeTuple *ti = d->tinfo->isTypeTuple (); /* The vtable for TypeInfo_Tuple. */ this->layout_base (Type::typeinfotypelist); @@ -1323,8 +1313,7 @@ public: void visit (TypeInfoClassDeclaration *tid) { - gcc_assert (tid->tinfo->ty == Tclass); - TypeClass *tc = (TypeClass *) tid->tinfo; + TypeClass *tc = tid->tinfo->isTypeClass (); tid->csym = get_classinfo_decl (tc->sym); } }; diff --git a/gcc/d/types.cc b/gcc/d/types.cc index f3a1c473f7a..cb9a6dec7e5 100644 --- a/gcc/d/types.cc +++ b/gcc/d/types.cc @@ -498,9 +498,9 @@ merge_aggregate_types (Type *type, tree deco) AggregateDeclaration *sym; if (type->ty == Tstruct) - sym = ((TypeStruct *) type)->sym; + sym = type->isTypeStruct ()->sym; else if (type->ty == Tclass) - sym = ((TypeClass *) type)->sym; + sym = type->isTypeClass ()->sym; else gcc_unreachable (); @@ -671,7 +671,7 @@ public: void visit (TypeVector *t) { - int nunits = ((TypeSArray *) t->basetype)->dim->toUInteger (); + int nunits = t->basetype->isTypeSArray ()->dim->toUInteger (); tree inner = build_ctype (t->elementType ()); /* Same rationale as void static arrays. */ -- 2.30.2