Changeset f1b1e4c for src/ResolvExpr

Timestamp:

Jun 1, 2016, 11:54:23 AM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

be945ac

Parents:

70f89d00

Message:

can construct global const objects, except with intrinsic constructors

File:

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

src/ResolvExpr/Resolver.cc

@@ -52 +52 @@
                 virtual void visit( BranchStmt *branchStmt );
                 virtual void visit( ReturnStmt *returnStmt );
+                virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
 
                 virtual void visit( SingleInit *singleInit );
@@ -493 +494 @@
                         // 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?
-
-                        // reset type qualifiers
-                        ctorInit->get_object()->get_type()->get_qualifiers() = ctorInit->get_qualifiers();
                         fallbackInit( ctorInit );
                         return;
                 }
-                // reset type qualifiers
-                ctorInit->get_object()->get_type()->get_qualifiers() = ctorInit->get_qualifiers();
 
                 // found a constructor - can get rid of C-style initializer
@@ -518 +514 @@
                 }
         }
+
+        void Resolver::visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) {
+                // this code is fairly gross. If VariableExpr didn't have its own results list then this could be cleaned up a bit
+                // by remembering the ObjectDecl in the ImplicitCtorDtorStmt and changing the ObjectDecl's type temporarily, but currently
+                // VariableExprs have their own type list which is manipulated in AlternativeFinder (e.g. in inferRecursive).
+
+                // before resolving ctor/dtor, need to remove type qualifiers from the first argument (the object being constructed)
+                Expression * callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
+                assert( callExpr );
+                Expression * constructee = InitTweak::getCallArg( callExpr, 0 );
+                Type * type = 0;
+                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 );
+                        ArrayType * arrType = dynamic_cast< ArrayType * >( arr->get_results().front() );
+                        assert( arrType );
+                        type = arrType->get_base();
+                } 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 );
+                        VariableExpr * varExpr = dynamic_cast< VariableExpr * >( addrExpr->get_arg() );
+                        assert( varExpr && varExpr->get_results().size() == 1 );
+                        type = varExpr->get_results().front();
+                }
+                // remember qualifiers so they can be replaced
+                Type::Qualifiers qualifiers = type->get_qualifiers();
+
+                // 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->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
+
+                // finally, resolve the ctor/dtor
+                impCtorDtorStmt->get_callStmt()->accept( *this );
+
+                // and reset type qualifiers after resolving
+                type->get_qualifiers() = qualifiers;
+        }
 } // namespace ResolvExpr