Changeset 4d2d45f9

Timestamp:

Apr 9, 2019, 1:50:13 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

c41c18a6

Parents:

5806745

Message:

Improve assertion error messages

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (1 diff)
• ResolveAssertions.cc (modified) (6 diffs)
• ResolveAssertions.h (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -258 +258 @@
                         // - necessary pre-requisite to pruning
                         AltList candidates;
+                        std::list<std::string> errors;
                         for ( unsigned i = 0; i < alternatives.size(); ++i ) {
-                                resolveAssertions( alternatives[i], indexer, candidates );
+                                resolveAssertions( alternatives[i], indexer, candidates, errors );
                         }
                         // fail early if none such
                         if ( mode.failFast && candidates.empty() ) {
                                 std::ostringstream stream;
-                                stream << "No resolvable alternatives for expression " << expr << "\n"
-                                       << "Alternatives with failing assertions are:\n";
-                                printAlts( alternatives, stream, 1 );
+                                stream << "No alternatives with satisfiable assertions for " << expr << "\n";
+                                //        << "Alternatives with failing assertions are:\n";
+                                // printAlts( alternatives, stream, 1 );
+                                for ( const auto& err : errors ) {
+                                        stream << err;
+                                }
                                 SemanticError( expr->location, stream.str() );
                         }

src/ResolvExpr/ResolveAssertions.cc

@@ -20 +20 @@
 #include <list>                     // for list
 #include <memory>                   // for unique_ptr
-#include <string>
+#include <sstream>                  // for ostringstream
+#include <string>                   // for string
 #include <unordered_map>            // for unordered_map, unordered_multimap
 #include <utility>                  // for move
@@ -27 +28 @@
 #include "Alternative.h"            // for Alternative, AssertionItem, AssertionList
 #include "Common/FilterCombos.h"    // for filterCombos
+#include "Common/Indenter.h"        // for Indenter
 #include "Common/utility.h"         // for sort_mins
 #include "ResolvExpr/RenameVars.h"  // for renameTyVars
@@ -97 +99 @@
                         return { item, item.matches[i] };
                 }
+
+                const DeclarationWithType* get_decl() const { return cache->at(key).deferIds[0].decl; }
 
                 // sortable by key
@@ -364 +368 @@
         static const int recursionLimit = /* 10 */ 4;
 
-        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out ) {
+        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out, std::list<std::string>& errors ) {
                 // finish early if no assertions to resolve
                 if ( alt.need.empty() ) {
@@ -385 +389 @@
                                 for ( auto& assn : resn.need ) {
                                         // fail early if any assertion is not resolvable
-                                        if ( ! resolveAssertion( assn, resn, assnCache ) ) goto nextResn;
+                                        if ( ! resolveAssertion( assn, resn, assnCache ) ) {
+                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                std::ostringstream ss;
+                                                ss << tabs << "Unsatisfiable alternative:\n";
+                                                resn.alt.print( ss, ++tabs );
+                                                ss << --tabs << "Could not satisfy assertion:\n";
+                                                assn.decl->print( ss, ++tabs );
+                                                
+                                                errors.emplace_back( ss.str() );
+                                                goto nextResn;
+                                        }
                                 }
 
@@ -404 +418 @@
                                                 resn.deferred, 
                                                 CandidateEnvMerger{ resn.alt.env, resn.alt.openVars, resn.indexer } );
+                                        // fail early if no mutually-compatible assertion satisfaction
+                                        if ( compatible.empty() ) {
+                                                Indenter tabs{ Indenter::tabsize, 3 };
+                                                std::ostringstream ss;
+                                                ss << tabs << "Unsatisfiable alternative:\n";
+                                                resn.alt.print( ss, ++tabs );
+                                                ss << --tabs << "No mutually-compatible satisfaction for assertions:\n";
+                                                ++tabs;
+                                                for ( const auto& d : resn.deferred ) {
+                                                        d.get_decl()->print( ss, tabs );
+                                                }
+
+                                                errors.emplace_back( ss.str() );
+                                                goto nextResn;
+                                        }
                                         // sort by cost
                                         CandidateCost coster{ resn.indexer };

src/ResolvExpr/ResolveAssertions.h

@@ -24 +24 @@
 namespace ResolvExpr {
         /// Recursively resolves all assertions provided in an alternative; returns true iff succeeds
-        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out );
+        void resolveAssertions( Alternative& alt, const SymTab::Indexer& indexer, AltList& out, std::list<std::string>& errors );
 } // namespace ResolvExpr