d: Use new isXxxxExp helpers where possible

gcc/d/ChangeLog:

	* d-attribs.cc (build_attributes): Use isXxxxExp helpers instead of
	explicit casts.
	* d-codegen.cc (d_build_call): Likewise.
	* d-compiler.cc (Compiler::paintAsType): Likewise.
	* decl.cc (ExprVisitor::visit): Likewise.
	(layout_class_initializer): Likewise.
	* expr.cc (ExprVisitor::lvalue_p): Likewise
	(ExprVisitor::visit): Likewise.
	* types.cc (layout_aggregate_members): Likewise.

diff --git a/gcc/d/d-attribs.cc b/gcc/d/d-attribs.cc
index b83db95e2a7aaabb1baf48964bb4cee58f5ccb6e..7e55b42fd03c80ae72fc1c1535a0c5f5b27c332e 100644 (file)
--- a/gcc/d/d-attribs.cc
+++ b/gcc/d/d-attribs.cc
@@ -268,7 +268,7 @@ build_attributes (Expressions *eattrs)
       /* Should now have a struct `Attribute("attrib", "value", ...)'
         initializer list.  */
       gcc_assert (attr->op == TOKstructliteral);
-      Expressions *elems = ((StructLiteralExp*) attr)->elements;
+      Expressions *elems = attr->isStructLiteralExp ()->elements;
       Expression *e0 = (*elems)[0];
 
       if (e0->op != TOKstring)
@@ -300,10 +300,10 @@ build_attributes (Expressions *eattrs)
       for (size_t j = 1; j < elems->length; j++)
        {
          Expression *e = (*elems)[j];
+         StringExp *s = e->isStringExp ();
          tree t;
-         if (e->op == TOKstring && ((StringExp *) e)->sz == 1)
+         if (s != NULL && s->sz == 1)
            {
-             StringExp *s = (StringExp *) e;
              const char *string = (const char *)(s->len ? s->string : "");
              t = build_string (s->len, string);
            }

diff --git a/gcc/d/d-codegen.cc b/gcc/d/d-codegen.cc
index 1bf74e1f223effa44997c7d53f8cb7678dc12225..d31638e2c1d2e09e7598aca728475e99f74e1d82 100644 (file)
--- a/gcc/d/d-codegen.cc
+++ b/gcc/d/d-codegen.cc
@@ -1874,7 +1874,7 @@ d_build_call (TypeFunction *tf, tree callable, tree object,
 
          if (arg->op == TOKcomma)
            {
-             CommaExp *ce = (CommaExp *) arg;
+             CommaExp *ce = arg->isCommaExp ();
              tree tce = build_expr (ce->e1);
              saved_args = compound_expr (saved_args, tce);
              (*arguments)[i] = ce->e2;

diff --git a/gcc/d/d-compiler.cc b/gcc/d/d-compiler.cc
index 75ca15737d94e18d90a6ab074db0dd24784425f9..41b3b53207aafc11fb9053bb2f2907896c37173d 100644 (file)
--- a/gcc/d/d-compiler.cc
+++ b/gcc/d/d-compiler.cc
@@ -88,7 +88,7 @@ Compiler::paintAsType (UnionExp *, Expression *expr, Type *type)
   else if (expr->op == TOKarrayliteral)
     {
       /* Build array as VECTOR_CST, assumes EXPR is constant.  */
-      Expressions *elements = ((ArrayLiteralExp *) expr)->elements;
+      Expressions *elements = expr->isArrayLiteralExp ()->elements;
       vec<constructor_elt, va_gc> *elms = NULL;
 
       vec_safe_reserve (elms, elements->length);
@@ -136,7 +136,7 @@ Compiler::paintAsType (UnionExp *, Expression *expr, Type *type)
       Expression *e = d_eval_constant_expression (cst);
       gcc_assert (e != NULL && e->op == TOKvector);
 
-      return ((VectorExp *) e)->e1;
+      return e->isVectorExp ()->e1;
     }
   else
     {

diff --git a/gcc/d/decl.cc b/gcc/d/decl.cc
index a6144f7c269f28ff69549df53cf675716170fed0..28d1d6d5f31dfafb9c931ae3c7294fd3dd59de11 100644 (file)
--- a/gcc/d/decl.cc
+++ b/gcc/d/decl.cc
@@ -218,12 +218,11 @@ public:
     for (size_t i = 0; i < d->objects->length; i++)
       {
        RootObject *o = (*d->objects)[i];
-       if ((o->dyncast () == DYNCAST_EXPRESSION)
-           && ((Expression *) o)->op == TOKdsymbol)
+       if (o->dyncast () == DYNCAST_EXPRESSION)
          {
-           Declaration *d = ((DsymbolExp *) o)->s->isDeclaration ();
-           if (d)
-             this->build_dsymbol (d);
+           DsymbolExp *de = ((Expression *) o)->isDsymbolExp ();
+           if (de != NULL && de->s->isDeclaration ())
+             this->build_dsymbol (de->s);
          }
       }
   }
@@ -2239,7 +2238,7 @@ layout_class_initializer (ClassDeclaration *cd)
   Expression *e = ne->ctfeInterpret ();
   gcc_assert (e->op == TOKclassreference);
 
-  return build_class_instance ((ClassReferenceExp *) e);
+  return build_class_instance (e->isClassReferenceExp ());
 }
 
 tree

diff --git a/gcc/d/expr.cc b/gcc/d/expr.cc
index 9c80db15552ae94c16a99de20241804bb3d1bf06..06cd83a737d1d74eb673a2dbb43537d62eb375ba 100644 (file)
--- a/gcc/d/expr.cc
+++ b/gcc/d/expr.cc
@@ -90,9 +90,15 @@ class ExprVisitor : public Visitor
 
   bool lvalue_p (Expression *e)
   {
-    return ((e->op != TOKslice && e->isLvalue ())
-           || (e->op == TOKslice && ((UnaExp *) e)->e1->isLvalue ())
-           || (e->op == TOKcast && ((UnaExp *) e)->e1->isLvalue ()));
+    SliceExp *se = e->isSliceExp ();
+    if (se != NULL && se->e1->isLvalue ())
+      return true;
+
+    CastExp *ce = e->isCastExp ();
+    if (ce != NULL && ce->e1->isLvalue ())
+      return true;
+
+    return (e->op != TOKslice && e->isLvalue ());
   }
 
   /* Build an expression of code CODE, data type TYPE, and operands ARG0 and
@@ -174,7 +180,7 @@ class ExprVisitor : public Visitor
     Expression *e1b = e1;
     while (e1b->op == TOKcast)
       {
-       CastExp *ce = (CastExp *) e1b;
+       CastExp *ce = e1b->isCastExp ();
        gcc_assert (same_type_p (ce->type, ce->to));
        e1b = ce->e1;
       }
@@ -679,7 +685,7 @@ public:
          {
            if (ex->op == TOKcat)
              {
-               ex = ((CatExp *) ex)->e1;
+               ex = ex->isCatExp ()->e1;
                ndims++;
              }
          }
@@ -696,7 +702,7 @@ public:
        for (Expression *oe = ce->e2; oe != NULL;
             (ce->e1->op != TOKcat
              ? (oe = ce->e1)
-             : (ce = (CatExp *)ce->e1, oe = ce->e2)))
+             : (ce = ce->e1->isCatExp (), oe = ce->e2)))
          {
            tree arg = d_array_convert (etype, oe);
            tree index = size_int (dim);
@@ -790,7 +796,7 @@ public:
           Strip off casts just incase anyway.  */
        while (e1b->op == TOKcast)
          {
-           CastExp *ce = (CastExp *) e1b;
+           CastExp *ce = e1b->isCastExp ();
            gcc_assert (same_type_p (ce->type, ce->to));
            e1b = ce->e1;
          }
@@ -883,7 +889,7 @@ public:
     if (e->e1->op == TOKarraylength)
       {
        /* Assignment to an array's length property; resize the array.  */
-       ArrayLengthExp *ale = (ArrayLengthExp *) e->e1;
+       ArrayLengthExp *ale = e->e1->isArrayLengthExp ();
        tree newlength = convert_expr (build_expr (e->e2), e->e2->type,
                                       Type::tsize_t);
        tree ptr = build_address (build_expr (ale->e1));
@@ -904,7 +910,7 @@ public:
     /* Look for array[] = n;  */
     if (e->e1->op == TOKslice)
       {
-       SliceExp *se = (SliceExp *) e->e1;
+       SliceExp *se = e->e1->isSliceExp ();
        Type *stype = se->e1->type->toBasetype ();
        Type *etype = stype->nextOf ()->toBasetype ();
 
@@ -998,7 +1004,7 @@ public:
        gcc_assert (e->op == TOKconstruct || e->op == TOKblit);
        gcc_assert (e->e1->op == TOKvar);
 
-       Declaration *decl = ((VarExp *) e->e1)->var;
+       Declaration *decl = e->e1->isVarExp ()->var;
        if (decl->storage_class & (STCout | STCref))
          {
            tree t2 = convert_for_assignment (build_expr (e->e2),
@@ -1443,7 +1449,7 @@ public:
 
        if (e->e1->op == TOKvar)
          {
-           VarDeclaration *v = ((VarExp *) e->e1)->var->isVarDeclaration ();
+           VarDeclaration *v = e->e1->isVarExp ()->var->isVarDeclaration ();
            if (v && v->onstack)
              {
                libcall = tb1->isClassHandle ()->isInterfaceDeclaration ()
@@ -1588,19 +1594,19 @@ public:
 
     if (e->e1->op == TOKadd)
       {
-       BinExp *be = (BinExp *) e->e1;
-       if (be->e1->op == TOKaddress
-           && be->e2->isConst () && be->e2->type->isintegral ())
+       AddExp *ae = e->e1->isAddExp ();
+       if (ae->e1->op == TOKaddress
+           && ae->e2->isConst () && ae->e2->type->isintegral ())
          {
-           Expression *ae = ((AddrExp *) be->e1)->e1;
-           tnext = ae->type->toBasetype ();
-           result = build_expr (ae);
-           offset = be->e2->toUInteger ();
+           Expression *ex = ae->e1->isAddrExp ()->e1;
+           tnext = ex->type->toBasetype ();
+           result = build_expr (ex);
+           offset = ae->e2->toUInteger ();
          }
       }
     else if (e->e1->op == TOKsymoff)
       {
-       SymOffExp *se = (SymOffExp *) e->e1;
+       SymOffExp *se = e->e1->isSymOffExp ();
        if (!declaration_reference_p (se->var))
          {
            tnext = se->var->type->toBasetype ();
@@ -1652,7 +1658,7 @@ public:
        Taking the address of a struct literal is otherwise illegal.  */
     if (e->e1->op == TOKstructliteral)
       {
-       StructLiteralExp *sle = ((StructLiteralExp *) e->e1)->origin;
+       StructLiteralExp *sle = e->e1->isStructLiteralExp ()->origin;
        gcc_assert (sle != NULL);
 
        /* Build the reference symbol, the decl is built first as the
@@ -1690,21 +1696,21 @@ public:
     /* Calls to delegates can sometimes look like this.  */
     if (e1b->op == TOKcomma)
       {
-       e1b = ((CommaExp *) e1b)->e2;
+       e1b = e1b->isCommaExp ()->e2;
        gcc_assert (e1b->op == TOKvar);
 
-       Declaration *var = ((VarExp *) e1b)->var;
+       Declaration *var = e1b->isVarExp ()->var;
        gcc_assert (var->isFuncDeclaration () && !var->needThis ());
       }
 
     if (e1b->op == TOKdotvar && tb->ty != Tdelegate)
       {
-       DotVarExp *dve = (DotVarExp *) e1b;
+       DotVarExp *dve = e1b->isDotVarExp ();
 
        /* Don't modify the static initializer for struct literals.  */
        if (dve->e1->op == TOKstructliteral)
          {
-           StructLiteralExp *sle = (StructLiteralExp *) dve->e1;
+           StructLiteralExp *sle = dve->e1->isStructLiteralExp ();
            sle->useStaticInit = false;
          }
 
@@ -1767,7 +1773,7 @@ public:
            /* This gets the true function type, getting the function type
               from e1->type can sometimes be incorrect, such as when calling
               a 'ref' return function.  */
-           tf = get_function_type (((DotVarExp *) e1b)->var->type);
+           tf = get_function_type (e1b->isDotVarExp ()->var->type);
          }
        else
          tf = get_function_type (tb);
@@ -1784,7 +1790,7 @@ public:
       }
     else if (e1b->op == TOKvar)
       {
-       FuncDeclaration *fd = ((VarExp *) e1b)->var->isFuncDeclaration ();
+       FuncDeclaration *fd = e1b->isVarExp ()->var->isFuncDeclaration ();
        gcc_assert (fd != NULL);
        tf = get_function_type (fd->type);
 
@@ -2145,7 +2151,7 @@ public:
   void visit (SymOffExp *e)
   {
     /* Build the address and offset of the symbol.  */
-    size_t soffset = ((SymOffExp *) e)->offset;
+    size_t soffset = e->isSymOffExp ()->offset;
     tree result = get_decl_tree (e->var);
     TREE_USED (result) = 1;
 
@@ -2956,7 +2962,7 @@ public:
     /* First handle array literal expressions.  */
     if (e->e1->op == TOKarrayliteral)
       {
-       ArrayLiteralExp *ale = ((ArrayLiteralExp *) e->e1);
+       ArrayLiteralExp *ale = e->e1->isArrayLiteralExp ();
        vec<constructor_elt, va_gc> *elms = NULL;
        bool constant_p = true;
 

diff --git a/gcc/d/types.cc b/gcc/d/types.cc
index cb9a6dec7e505fa13df20c75c3ac69e0d5881689..ba7e29a12e1e73339632294c15587c279fd5fad5 100644 (file)
--- a/gcc/d/types.cc
+++ b/gcc/d/types.cc
@@ -292,7 +292,7 @@ layout_aggregate_members (Dsymbols *members, tree context, bool inherited_p)
                  gcc_assert (ro->dyncast () == DYNCAST_EXPRESSION);
                  Expression *e = (Expression *) ro;
                  gcc_assert (e->op == TOKdsymbol);
-                 DsymbolExp *se = (DsymbolExp *) e;
+                 DsymbolExp *se = e->isDsymbolExp ();
 
                  tmembers.push (se->s);
                }