Changeset b5629d8 for src

Timestamp:

Dec 3, 2020, 1:49:01 PM (5 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:

62e456f, ab0257b9

Parents:

f0d67e5 (diff), fa11053 (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

Location:

src

Files:

• AST/Print.cpp (modified) (3 diffs)
• AST/Type.cpp (modified) (2 diffs)
• AST/Type.hpp (modified) (1 diff)
• AST/TypeEnvironment.cpp (modified) (2 diffs)
• Common/CodeLocation.h (modified) (1 diff)
• Common/SemanticError.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• ResolvExpr/TypeEnvironment.cc (modified) (1 diff)
• ResolvExpr/TypeEnvironment.h (modified) (1 diff)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/NamedTypeDecl.cc (modified) (2 diffs)
• SynTree/ReferenceToType.cc (modified) (2 diffs)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/Type.h (modified) (1 diff)

src/AST/Print.cpp

@@ -205 +205 @@
 
         void preprint( const ast::NamedTypeDecl * node ) {
-                if ( ! node->name.empty() ) os << node->name << ": ";
+                if ( ! node->name.empty() ) {
+                        if( deterministic_output && isUnboundType(node->name) ) os << "[unbound]:";
+                        else os << node->name << ": ";
+                }
 
                 if ( ! short_mode && node->linkage != Linkage::Cforall ) {
@@ -240 +243 @@
 
                 if ( node->result ) {
-                        if (!deterministic_output) {
-                                os << endl << indent << "... with resolved type:" << endl;
-                                ++indent;
-                                os << indent;
-                                node->result->accept( *this );
-                                --indent;
-                        }
+                        os << endl << indent << "... with resolved type:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->result->accept( *this );
+                        --indent;
                 }
 
@@ -1382 +1383 @@
         virtual const ast::Type * visit( const ast::TypeInstType * node ) override final {
                 preprint( node );
-                os << "instance of type " << node->name
+                const auto & _name = deterministic_output && isUnboundType(node) ? "[unbound]" : node->name;
+                os << "instance of type " << _name
                    << " (" << (node->kind == ast::TypeDecl::Ftype ? "" : "not ") << "function type)";
                 print( node->params );

src/AST/Type.cpp

@@ -133 +133 @@
 
 BaseInstType::BaseInstType( const BaseInstType & o )
-: ParameterizedType( o.qualifiers, copy( o.attributes ) ), params(), name( o.name ), 
+: ParameterizedType( o.qualifiers, copy( o.attributes ) ), params(), name( o.name ),
   hoistType( o.hoistType ) {
         Pass< ForallSubstitutor > sub;
@@ -222 +222 @@
                 // TODO: once TypeInstType representation is updated, it should properly check
                 // if the context id is filled. this is a temporary hack for now
-                if (std::count(typeInst->name.begin(), typeInst->name.end(), '_') >= 3) {
-                        return true;
-                }
+                return isUnboundType(typeInst->name);
+        }
+        return false;
+}
+
+bool isUnboundType(const std::string & tname) {
+        // xxx - look for a type name produced by renameTyVars.
+
+        // TODO: once TypeInstType representation is updated, it should properly check
+        // if the context id is filled. this is a temporary hack for now
+        if (std::count(tname.begin(), tname.end(), '_') >= 3) {
+                return true;
         }
         return false;

src/AST/Type.hpp

@@ -536 +536 @@
 
 bool isUnboundType(const Type * type);
+bool isUnboundType(const std::string & tname);
 
 }

src/AST/TypeEnvironment.cpp

@@ -34 +34 @@
 #include "ResolvExpr/Unify.h"      // for unifyInexact
 #include "Tuples/Tuples.h"         // for isTtype
+#include "CompilationState.h"
 
 using ResolvExpr::WidenMode;
@@ -56 +57 @@
 
 void print( std::ostream & out, const EqvClass & clz, Indenter indent ) {
-        out << "( ";
-        std::copy( clz.vars.begin(), clz.vars.end(), std::ostream_iterator< std::string >( out, " " ) );
+        out << "(";
+        bool first = true;
+        for(const auto & var : clz.vars) {
+                if(first) first = false;
+                else out << " ";
+                if( deterministic_output && isUnboundType(var) ) out << "[unbound]";
+                else out << var;
+        }
         out << ")";
 

src/Common/CodeLocation.h

@@ -42 +42 @@
         }
 
-        bool followedBy( CodeLocation const & other, int seperation ) {
+        bool startsBefore( CodeLocation const & other ) const {
+                if( filename < other.filename ) return true;
+                if( filename > other.filename ) return false;
+
+                if( first_line < other.first_line ) return true;
+                if( first_line > other.first_line ) return false;
+
+                if( last_line < other.last_line ) return true;
+                return false;
+        }
+
+        bool followedBy( CodeLocation const & other, int seperation ) const {
                 return (first_line + seperation == other.first_line &&
                         filename == other.filename);
         }
 
-        bool operator==( CodeLocation const & other ) {
+        bool operator==( CodeLocation const & other ) const {
                 return followedBy( other, 0 );
         }
 
-        bool operator!=( CodeLocation const & other ) {
+        bool operator!=( CodeLocation const & other ) const {
                 return !(*this == other);
         }

src/Common/SemanticError.cc

@@ -90 +90 @@
 void SemanticErrorException::print() {
         using std::to_string;
+
+        errors.sort([](const error & lhs, const error & rhs) -> bool {
+                if(lhs.location.startsBefore(rhs.location)) return true;
+                if(rhs.location.startsBefore(lhs.location)) return false;
+
+                return lhs.description < rhs.description;
+        });
+
         for( auto err : errors ) {
                 std::cerr << ErrorHelpers::bold() << err.location << ErrorHelpers::error_str() << ErrorHelpers::reset_font() << err.description << std::endl;

src/ResolvExpr/AlternativeFinder.cc

@@ -132 +132 @@
         void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt ) {
                 Indenter indent = { indentAmt };
+
+                std::vector<int> idx;
+                idx.reserve(list.size());
+                for(int i = 0; i < list.size(); i++) { idx.push_back(i); }
+
+                std::sort(idx.begin(), idx.end(), [&list](int lhs_idx, int rhs_idx) -> bool {
+                        const auto & lhs = list.at(lhs_idx);
+                        const auto & rhs = list.at(rhs_idx);
+                        if(lhs.expr->location.startsBefore(rhs.expr->location)) return true;
+                        if(rhs.expr->location.startsBefore(lhs.expr->location)) return false;
+
+                        if(lhs.env.size() < rhs.env.size()) return true;
+                        if(lhs.env.size() > rhs.env.size()) return false;
+
+                        if(lhs.openVars.size() < rhs.openVars.size()) return true;
+                        if(lhs.openVars.size() > rhs.openVars.size()) return false;
+
+                        if(lhs.need.size() < rhs.need.size()) return true;
+                        if(lhs.need.size() > rhs.need.size()) return false;
+
+                        return false;
+                });
+
                 for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
                         i->print( os, indent );
@@ -1718 +1741 @@
                                         std::cerr << std::endl;
                                 )
-                                
+
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away

src/ResolvExpr/TypeEnvironment.cc

@@ -107 +107 @@
 
         void EqvClass::print( std::ostream &os, Indenter indent ) const {
-                if( !deterministic_output ) {
-                        os << "( ";
-                        std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) );
-                        os << ")";
-                }
+                os << "(";
+                bool first = true;
+                for(const auto & var : vars) {
+                        if(first) first = false;
+                        else os << " ";
+                        if( deterministic_output && isUnboundType(var) ) os << "[unbound]";
+                        else os << var;
+                }
+                os << ")";
                 if ( type ) {
                         os << " -> ";

src/ResolvExpr/TypeEnvironment.h

@@ -149 +149 @@
                 iterator end() const { return env.end(); }
 
+                auto size() const { return env.size(); }
+
           private:
                 ClassList env;

src/SynTree/Expression.cc

@@ -72 +72 @@
 
         if ( result ) {
-                if (!deterministic_output) {
-                        os << std::endl << indent << "with resolved type:" << std::endl;
-                        os << (indent+1);
-                        result->print( os, indent+1 );
-                }
+                os << std::endl << indent << "with resolved type:" << std::endl;
+                os << (indent+1);
+                result->print( os, indent+1 );
         }
 

src/SynTree/NamedTypeDecl.cc

@@ -22 +22 @@
 #include "LinkageSpec.h"         // for Spec, Cforall, linkageName
 #include "Type.h"                // for Type, Type::StorageClasses
+#include "CompilationState.h"
 
 NamedTypeDecl::NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *base )
@@ -41 +42 @@
         using namespace std;
 
-        if ( name != "" ) os << name << ": ";
+        if ( ! name.empty() ) {
+                if( deterministic_output && isUnboundType(name) ) os << "[unbound]:";
+                else os << name << ": ";
+        }
 
         if ( linkage != LinkageSpec::Cforall ) {

src/SynTree/ReferenceToType.cc

@@ -24 +24 @@
 #include "Type.h"             // for TypeInstType, StructInstType, UnionInstType
 #include "TypeSubstitution.h" // for TypeSubstitution
+#include "CompilationState.h"
 
 class Attribute;
@@ -205 +206 @@
 
         Type::print( os, indent );
-        os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type)";
+        os << "instance of " << typeString() << " ";
+        const auto & name_ = get_name();
+        if( deterministic_output && isUnboundType(name) ) os << "[unbound]";
+        else os << name;
+        os << " (" << ( isFtype ? "" : "not" ) << " function type)";
         if ( ! parameters.empty() ) {
                 os << endl << indent << "... with parameters" << endl;

src/SynTree/Type.cc

@@ -156 +156 @@
 const Type::Qualifiers noQualifiers;
 
+bool isUnboundType(const Type * type) {
+        if (auto typeInst = dynamic_cast<const TypeInstType *>(type)) {
+                // xxx - look for a type name produced by renameTyVars.
+
+                // TODO: once TypeInstType representation is updated, it should properly check
+                // if the context id is filled. this is a temporary hack for now
+                return isUnboundType(typeInst->name);
+        }
+        return false;
+}
+
+bool isUnboundType(const std::string & tname) {
+        // xxx - look for a type name produced by renameTyVars.
+
+        // TODO: once TypeInstType representation is updated, it should properly check
+        // if the context id is filled. this is a temporary hack for now
+        if (std::count(tname.begin(), tname.end(), '_') >= 3) {
+                return true;
+        }
+        return false;
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Type.h

@@ -733 +733 @@
 };
 
+
+bool isUnboundType(const Type * type);
+bool isUnboundType(const std::string & tname);
+
 // Local Variables: //
 // tab-width: 4 //