Changes in src/ResolvExpr/Resolver.cc [a436947:7b3f66b]

File:

• src/ResolvExpr/Resolver.cc (modified) (7 diffs)

src/ResolvExpr/Resolver.cc

@@ -38 +38 @@
                 virtual void visit( ObjectDecl *functionDecl );
                 virtual void visit( TypeDecl *typeDecl );
-                virtual void visit( EnumDecl * enumDecl );
 
                 virtual void visit( ArrayType * at );
@@ -53 +52 @@
                 virtual void visit( BranchStmt *branchStmt );
                 virtual void visit( ReturnStmt *returnStmt );
-                virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
 
                 virtual void visit( SingleInit *singleInit );
@@ -67 +65 @@
                 Type *initContext;
                 Type *switchType;
-                bool inEnumDecl = false;
         };
 
@@ -180 +177 @@
                 Type *temp = initContext;
                 initContext = new_type;
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
-                        // enumerator initializers should not use the enum type to initialize, since
-                        // the enum type is still incomplete at this point. Use signed int instead.
-                        initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
-                }
                 SymTab::Indexer::visit( objectDecl );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
-                        // delete newly created signed int type
-                        delete initContext;
-                }
                 initContext = temp;
         }
@@ -227 +215 @@
                 SymTab::Indexer::visit( functionDecl );
                 functionReturn = oldFunctionReturn;
-        }
-
-        void Resolver::visit( EnumDecl * enumDecl ) {
-                // in case we decide to allow nested enums
-                bool oldInEnumDecl = inEnumDecl;
-                inEnumDecl = true;
-                SymTab::Indexer::visit( enumDecl );
-                inEnumDecl = oldInEnumDecl;
         }
 
@@ -512 +492 @@
                 } catch ( SemanticError ) {
                         // no alternatives for the constructor initializer - fallback on C-style initializer
-                        // xxx - not sure if this makes a ton of sense - should maybe never be able to have this situation?
+                        // xxx- not sure if this makes a ton of sense - should maybe never be able to have this situation?
                         fallbackInit( ctorInit );
                         return;
@@ -533 +513 @@
                 }
         }
-
-        void Resolver::visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) {
-                // before resolving ctor/dtor, need to remove type qualifiers from the first argument (the object being constructed).
-                // Do this through a cast expression to greatly simplify the code.
-                Expression * callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
-                assert( callExpr );
-                Expression *& constructee = InitTweak::getCallArg( callExpr, 0 );
-                Type * type = 0;
-
-                // need to find the type of the first argument, which is unfortunately not uniform since array construction
-                // includes an untyped '+' expression.
-                if ( UntypedExpr * plusExpr = dynamic_cast< UntypedExpr * >( constructee ) ) {
-                        // constructee is <array>+<index>
-                        // get Variable <array>, then get the base type of the VariableExpr - this is the type that needs to be fixed
-                        Expression * arr = InitTweak::getCallArg( plusExpr, 0 );
-                        assert( dynamic_cast< VariableExpr * >( arr ) );
-                        assert( arr && arr->get_results().size() == 1 );
-                        type = arr->get_results().front()->clone();
-                } else {
-                        // otherwise, constructing a plain object, which means the object's address is being taken.
-                        // Need to get the type of the VariableExpr object, because the AddressExpr is rebuilt and uses the
-                        // type of the VariableExpr to do so.
-                        assert( constructee->get_results().size() == 1 );
-                        AddressExpr * addrExpr = dynamic_cast< AddressExpr * > ( constructee );
-                        assert( addrExpr && addrExpr->get_results().size() == 1);
-                        type = addrExpr->get_results().front()->clone();
-                }
-                // cast to T* with qualifiers removed.
-                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
-                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
-                // remove lvalue as a qualifier, this can change to
-                //   type->get_qualifiers() = Type::Qualifiers();
-                Type * base = InitTweak::getPointerBase( type );
-                assert( base );
-                base->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
-                // if pointer has lvalue qualifier, cast won't appear in output
-                type->set_isLvalue( false );
-                constructee = new CastExpr( constructee, type );
-
-                // finally, resolve the ctor/dtor
-                impCtorDtorStmt->get_callStmt()->accept( *this );
-        }
 } // namespace ResolvExpr