Changeset c0bf94e

Timestamp:

Apr 17, 2018, 4:24:05 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

27aca84

Parents:

a3323db1

Message:

Add isGenerated flag to CastExpr? to differentiate casts in source from compiler-generated casts

Location:

src

Files:

• Parser/ExpressionNode.cc (modified) (3 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (5 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)

src/Parser/ExpressionNode.cc

@@ -211 +211 @@
         if ( Unsigned && size < 2 ) {                                           // hh or h, less than int ?
                 // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
-                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
         } else if ( lnth != -1 ) {                                                      // explicit length ?
                 if ( lnth == 5 ) {                                                              // int128 ?
                         size = 5;
-                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
                 } else {
-                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ) );
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false );
                 } // if
         } // if
@@ -285 +285 @@
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
         if ( lnth != -1 ) {                                                                     // explicit length ?
-                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ) );
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ), false );
         } // if
 
@@ -408 +408 @@
         if ( dynamic_cast< VoidType * >( targetType ) ) {
                 delete targetType;
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node) );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false );
         } else {
-                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType );
+                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false );
         } // if
 } // build_cast

src/ResolvExpr/AlternativeFinder.cc

@@ -1247 +1247 @@
         }
 
-        Expression * restructureCast( Expression * argExpr, Type * toType ) {
+        Expression * restructureCast( Expression * argExpr, Type * toType, bool isGenerated ) {
                 if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() && ! dynamic_cast<ReferenceType *>( toType ) ) {
                         // Argument expression is a tuple and the target type is not void and not a reference type.
@@ -1262 +1262 @@
                                 // cast each component
                                 TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
-                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
+                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ), isGenerated ) );
                         }
                         delete argExpr;
@@ -1270 +1270 @@
                 } else {
                         // handle normally
-                        return new CastExpr( argExpr, toType->clone() );
+                        CastExpr * ret = new CastExpr( argExpr, toType->clone() );
+                        ret->isGenerated = isGenerated;
+                        return ret;
                 }
         }
@@ -1314 +1316 @@
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
-                                Alternative newAlt( restructureCast( alt.expr->clone(), toType ), alt.env,
+                                Alternative newAlt( restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), alt.env,
                                         alt.cost, thisCost );
                                 inferParameters( needAssertions, haveAssertions, newAlt, openVars,
@@ -1730 +1732 @@
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
-                                        Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
+                                        Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType, true ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
                                         inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
                                 }

src/SynTree/Expression.cc

@@ -271 +271 @@
 }
 
-CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
 }
 

src/SynTree/Expression.h

@@ -188 +188 @@
   public:
         Expression * arg;
-
-        CastExpr( Expression * arg );
-        CastExpr( Expression * arg, Type * toType );
+        bool isGenerated = true; // whether this cast appeared in the source program
+
+        CastExpr( Expression * arg, bool isGenerated = true );
+        CastExpr( Expression * arg, Type * toType, bool isGenerated = true );
         CastExpr( const CastExpr & other );
         virtual ~CastExpr();