Changeset 695e00d for src/Common

Timestamp:

Sep 19, 2017, 2:14:39 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, stuck-waitfor-destruct, with_gc

Children:

8f98b78

Parents:

e149f77 (diff), e06be49 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/Common/PassVisitor.impl.h (modified) (11 diffs)

src/Common/PassVisitor.impl.h

@@ -183 +183 @@
 
                 } catch ( SemanticError &e ) {
+                        e.set_location( (*i)->location );
                         errors.append( e );
                 }
@@ -292 +293 @@
 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
+// A NOTE ON THE ORDER OF TRAVERSAL
+//
+// Types and typedefs have their base types visited before they are added to the type table.  This is ok, since there is
+// no such thing as a recursive type or typedef.
+//
+//             typedef struct { T *x; } T; // never allowed
+//
+// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
+// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
+// declaration).
+//
+//             struct T { struct T *x; }; // allowed
+//
+// It is important to add the complete type to the symbol table *after* the members/base has been traversed, since that
+// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
+// queried later in this pass.
+//
+// TODO: figure out whether recursive contexts are sensible/possible/reasonable.
 
 //--------------------------------------------------------------------------
@@ -449 +468 @@
         indexerAddEnum( node );
 
-        // unlike structs, contexts, and unions, enums inject their members into the global scope
+        // unlike structs, traits, and unions, enums inject their members into the global scope
         maybeAccept( node->parameters, *this );
         maybeAccept( node->members   , *this );
@@ -513 +532 @@
         }
 
+        // see A NOTE ON THE ORDER OF TRAVERSAL, above
+        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
+        // and may depend on the type itself
         indexerAddType( node );
 
@@ -532 +554 @@
         }
 
+        // see A NOTE ON THE ORDER OF TRAVERSAL, above
+        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
+        // and may depend on the type itself
         indexerAddType( node );
 
@@ -658 +683 @@
 void PassVisitor< pass_type >::visit( IfStmt * node ) {
         VISIT_START( node );
-
-        visitExpression( node->condition );
-        node->thenPart = visitStatement( node->thenPart );
-        node->elsePart = visitStatement( node->elsePart );
-
+        {
+                // if statements introduce a level of scope (for the initialization)
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                acceptAll( node->get_initialization(), *this );
+                visitExpression( node->condition );
+                node->thenPart = visitStatement( node->thenPart );
+                node->elsePart = visitStatement( node->elsePart );
+        }
         VISIT_END( node );
 }
@@ -670 +698 @@
         MUTATE_START( node );
         {
-                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                // if statements introduce a level of scope (for the initialization)
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->get_initialization(), *this );
                 node->condition = mutateExpression( node->condition );
                 node->thenPart  = mutateStatement ( node->thenPart  );
@@ -706 +736 @@
         VISIT_START( node );
         {
+                // for statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->initialization, *this );
@@ -719 +750 @@
         MUTATE_START( node );
         {
+                // for statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->initialization, *this );
@@ -847 +879 @@
         VISIT_START( node );
         {
+                // catch statements introduce a level of scope (for the caught exception)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->decl, *this );
@@ -859 +892 @@
         MUTATE_START( node );
         {
+                // catch statements introduce a level of scope (for the caught exception)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->decl, *this );