Changeset e3e16bc for src/ResolvExpr

Timestamp:

Sep 13, 2017, 2:34:55 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

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, resolv-new, with_gc

Children:

982832e

Parents:

9f5ecf5

Message:

Renamed safe_dynamic_cast to strict_dynamic_cast

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (4 diffs)
• CommonType.cc (modified) (4 diffs)
• ConversionCost.cc (modified) (1 diff)
• CurrentObject.cc (modified) (2 diffs)
• Resolver.cc (modified) (5 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -15 +15 @@
 
 #include <algorithm>               // for copy
-#include <cassert>                 // for safe_dynamic_cast, assert, assertf
+#include <cassert>                 // for strict_dynamic_cast, assert, assertf
 #include <iostream>                // for operator<<, cerr, ostream, endl
 #include <iterator>                // for back_insert_iterator, back_inserter
@@ -336 +336 @@
 
         Cost computeApplicationConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
-                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
-                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
-                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( alt.expr );
+                PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
 
                 Cost convCost = Cost::zero;
@@ -494 +494 @@
                         Cost cost = Cost::zero;
                         std::list< Expression * > newExprs;
-                        ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
+                        ObjectDecl * obj = strict_dynamic_cast< ObjectDecl * >( formal );
                         if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) {
                                 deleteAll( newExprs );
@@ -787 +787 @@
 
                         PRINT(
-                                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
-                                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
-                                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                                ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( withFunc->expr );
+                                PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                                FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
                                 std::cerr << "Case +++++++++++++ " << appExpr->get_function() << std::endl;
                                 std::cerr << "formals are:" << std::endl;

src/ResolvExpr/CommonType.cc

@@ -14 +14 @@
 //
 
-#include <cassert>                       // for safe_dynamic_cast
+#include <cassert>                       // for strict_dynamic_cast
 #include <map>                           // for _Rb_tree_const_iterator
 #include <utility>                       // for pair
@@ -100 +100 @@
                         // special case where one type has a reference depth of 1 larger than the other
                         if ( diff > 0 ) {
-                                return handleReference( safe_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
+                                return handleReference( strict_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
                         } else if ( diff < 0 ) {
-                                return handleReference( safe_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
+                                return handleReference( strict_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
                         }
                         // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor.
@@ -114 +114 @@
                                 if ( TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 ) ) {
                                         if ( NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ) ) {
-                                                TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
+                                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
                                                 if ( type->get_base() ) {
                                                         Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
@@ -301 +301 @@
                         NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
                         if ( nt ) {
-                                TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
+                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
                                 if ( type->get_base() ) {
                                         Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers();

src/ResolvExpr/ConversionCost.cc

@@ -95 +95 @@
                 if ( diff > 0 ) {
                         // TODO: document this
-                        Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
+                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
                         cost.incReference();
                         return cost;
                 } else if ( diff < -1 ) {
                         // TODO: document this
-                        Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
+                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
                         cost.incReference();
                         return cost;

src/ResolvExpr/CurrentObject.cc

@@ -286 +286 @@
                                 for ( InitAlternative & alt : ret ) {
                                         PRINT( std::cerr << "iterating and adding designators" << std::endl; )
-                                        alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) );
+                                        alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) );
                                         // need to substitute for generic types, so that casts are to concrete types
                                         PRINT( std::cerr << "  type is: " << alt.type; )
@@ -346 +346 @@
                                 for ( InitAlternative & alt : ret ) {
                                         PRINT( std::cerr << "iterating and adding designators" << std::endl; )
-                                        alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) );
+                                        alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) );
                                 }
                         }

src/ResolvExpr/Resolver.cc

@@ -15 +15 @@
 
 #include <stddef.h>                      // for NULL
-#include <cassert>                       // for safe_dynamic_cast, assert
+#include <cassert>                       // for strict_dynamic_cast, assert
 #include <memory>                        // for allocator, allocator_traits<...
 #include <tuple>                         // for get
@@ -342 +342 @@
                         CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
                         Expression * newExpr = findSingleExpression( castExpr, *this );
-                        castExpr = safe_dynamic_cast< CastExpr * >( newExpr );
+                        castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
                         caseStmt->set_condition( castExpr->get_arg() );
                         castExpr->set_arg( nullptr );
@@ -398 +398 @@
                 Parent::enterScope();
                 Visitor::visit( catchStmt );
-                
+
                 if ( catchStmt->get_cond() ) {
                         Expression * wrapped = new CastExpr(
@@ -423 +423 @@
                 UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
                 Expression * newExpr = findSingleExpression( untyped, *this );
-                InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
+                InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
 
                 // move cursor to the object that is actually initialized
@@ -445 +445 @@
                                         if ( isCharType( pt->get_base() ) ) {
                                                 // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
-                                                CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
+                                                CastExpr *ce = strict_dynamic_cast< CastExpr * >( newExpr );
                                                 newExpr = ce->get_arg();
                                                 ce->set_arg( nullptr );