Changeset 95eec2c

Timestamp:

Jan 4, 2021, 3:49:19 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

ed1a6374

Parents:

c04a19e (diff), 1958fec (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

Files:

• libcfa/src/memory.cfa (modified) (2 diffs)
• libcfa/src/stdlib.hfa (modified) (1 diff)
• src/ResolvExpr/RenameVars.cc (modified) (2 diffs)
• src/ResolvExpr/RenameVars.h (modified) (1 diff)
• src/ResolvExpr/Resolver.cc (modified) (1 diff)
• src/ResolvExpr/SatisfyAssertions.cpp (modified) (4 diffs)

libcfa/src/memory.cfa

@@ -66 +66 @@
 forall(dtype T | sized(T), ttype Args | { void ?{}(T&, Args); })
 void ?{}(counter_ptr(T) & this, Args args) {
-        this.data = new(args);
+        this.data = (counter_data(T)*)new(args);
 }
 
@@ -126 +126 @@
 forall(dtype T | sized(T), ttype Args | { void ?{}(T &, Args); })
 void ?{}(unique_ptr(T) & this, Args args) {
-        this.data = new(args);
+        this.data = (T *)new(args);
 }
 

libcfa/src/stdlib.hfa

@@ -267 +267 @@
 static inline forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } )
 T * new( TT p ) {
-        return &(*malloc()){ p };                                                       // run constructor
+        return &(*(T *)malloc()){ p };                                                  // run constructor
 } // new
 

src/ResolvExpr/RenameVars.cc

@@ -186 +186 @@
 }
 
-const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode ) {
+const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode, bool reset ) {
         // ast::Type *tc = ast::deepCopy(t);
         ast::Pass<RenameVars_new> renamer;
         renamer.core.mode = mode;
-        if (mode == GEN_USAGE) {
+        if (mode == GEN_USAGE && reset) {
                 renaming.nextUsage();
         }
@@ -198 +198 @@
 void resetTyVarRenaming() {
         renaming.reset();
+        renaming.nextUsage();
 }
 

src/ResolvExpr/RenameVars.h

@@ -35 +35 @@
                 GEN_EXPR_ID // for type in decl
         };
-        const ast::Type * renameTyVars( const ast::Type *, RenameMode mode = GEN_USAGE );
+        const ast::Type * renameTyVars( const ast::Type *, RenameMode mode = GEN_USAGE, bool reset = true );
+        
 
         /// resets internal state of renamer to avoid overflow

src/ResolvExpr/Resolver.cc

@@ -1151 +1151 @@
                         const ast::Expr * untyped, const ast::SymbolTable & symtab
                 ) {
-                        resetTyVarRenaming();
                         ast::TypeEnvironment env;
                         ast::ptr< ast::Expr > newExpr = resolveInVoidContext( untyped, symtab, env );

src/ResolvExpr/SatisfyAssertions.cpp

@@ -202 +202 @@
                         ast::ptr< ast::Type > toType = assn.first->result;
                         ast::ptr< ast::Type > adjType = 
-                                renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ) );
+                                renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ), GEN_USAGE, false );
 
                         // only keep candidates which unify
@@ -385 +385 @@
 
         /// Limit to depth of recursion of assertion satisfaction
-        static const int recursionLimit = 4;
+        static const int recursionLimit = 8;
         /// Maximum number of simultaneously-deferred assertions to attempt concurrent satisfaction of
         static const int deferLimit = 10;
@@ -417 +417 @@
                         if ( it != thresholds.end() && it->second < sat.costs ) goto nextSat;
 
-                        // make initial pass at matching assertions
-                        for ( auto & assn : sat.need ) {
-                                // fail early if any assertion is not satisfiable
-                                if ( ! satisfyAssertion( assn, sat ) ) {
+                        // should a limit be imposed? worst case here is O(n^2) but very unlikely to happen.
+                        for (unsigned resetCount = 0; ; ++resetCount) { 
+                                ast::AssertionList next;
+                                resetTyVarRenaming();
+                                // make initial pass at matching assertions
+                                for ( auto & assn : sat.need ) {
+                                        // fail early if any assertion is not satisfiable
+                                        if ( ! satisfyAssertion( assn, sat ) ) {
+                                                next.emplace_back(assn);
+                                                // goto nextSat;
+                                        }
+                                }
+                                // success
+                                if (next.empty()) break;
+                                // fail if nothing resolves
+                                else if (next.size() == sat.need.size()) {
                                         Indenter tabs{ 3 };
                                         std::ostringstream ss;
@@ -426 +438 @@
                                         print( ss, *sat.cand, ++tabs );
                                         ss << (tabs-1) << "Could not satisfy assertion:\n";
-                                        ast::print( ss, assn.first, tabs );
+                                        ast::print( ss, next[0].first, tabs );
 
                                         errors.emplace_back( ss.str() );
                                         goto nextSat;
                                 }
+                                sat.need = std::move(next);
                         }