Changeset f474e91 for src/AST

Timestamp:

Jun 3, 2019, 5:36:43 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

4ae2364

Parents:

8d70648

Message:

Port unification calculations to new AST

Location:

src/AST

Files:

• Decl.hpp (modified) (1 diff)
• TypeEnvironment.cpp (modified) (14 diffs)
• TypeEnvironment.hpp (modified) (2 diffs)
• porting.md (modified) (1 diff)

src/AST/Decl.hpp

@@ -102 +102 @@
         ptr<Expr> bitfieldWidth;
 
-        ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type, Init * init = nullptr,
-                Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C, Expr * bitWd = nullptr,
-                std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {})
+        ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type, 
+                Init * init = nullptr, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C, 
+                Expr * bitWd = nullptr, std::vector< ptr<Attribute> > && attrs = {}, 
+                Function::Specs fs = {} )
         : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
           init( init ), bitfieldWidth( bitWd ) {}

src/AST/TypeEnvironment.cpp

@@ -46 +46 @@
 }
 
-void print( std::ostream & out, const OpenVarSet & openVars, Indenter indent ) {
+void print( std::ostream & out, const OpenVarSet & open, Indenter indent ) {
         out << indent;
         bool first = true;
-        for ( const auto & i : openVars ) {
+        for ( const auto & i : open ) {
                 if ( first ) { first = false; } else { out << ' '; }
                 out << i.first << "(" << i.second << ")";
@@ -166 +166 @@
 
 bool TypeEnvironment::combine( 
-                const TypeEnvironment & o, OpenVarSet & openVars, const SymbolTable & symtab ) {
+                const TypeEnvironment & o, OpenVarSet & open, const SymbolTable & symtab ) {
         // short-circuit easy cases
         if ( o.empty() ) return true;
@@ -189 +189 @@
                         EqvClass & r = *rt;
                         // merge bindings
-                        if ( ! mergeBound( r, c, openVars, symtab ) ) return false;
+                        if ( ! mergeBound( r, c, open, symtab ) ) return false;
                         // merge previous unbound variables into this class, checking occurs if needed
                         if ( r.bound ) for ( const auto & u : c.vars ) {
@@ -204 +204 @@
                                 } else if ( st != rt ) {
                                         // bound, but not to the same class
-                                        if ( ! mergeClasses( rt, st, openVars, symtab ) ) return false;
+                                        if ( ! mergeClasses( rt, st, open, symtab ) ) return false;
                                 }       // ignore bound into the same class
                         }
@@ -216 +216 @@
 }
 
-void TypeEnvironment::extractOpenVars( OpenVarSet & openVars ) const {
+void TypeEnvironment::extractOpenVars( OpenVarSet & open ) const {
         for ( const auto & clz : env ) {
                 for ( const auto & var : clz.vars ) {
-                        openVars[ var ] = clz.data;
-                }
-        }
-}
-
-void TypeEnvironment::addActual( const TypeEnvironment & actualEnv, OpenVarSet & openVars ) {
+                        open[ var ] = clz.data;
+                }
+        }
+}
+
+void TypeEnvironment::addActual( const TypeEnvironment & actualEnv, OpenVarSet & open ) {
         for ( const auto & clz : actualEnv ) {
                 EqvClass c = clz;
                 c.allowWidening = false;
                 for ( const auto & var : c.vars ) {
-                        openVars[ var ] = c.data;
+                        open[ var ] = c.data;
                 }
                 env.emplace_back( std::move(c) );
@@ -268 +268 @@
 bool TypeEnvironment::bindVar( 
                 const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, 
-                AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, 
-                WidenMode widenMode, const SymbolTable & symtab ) {
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen, 
+                const SymbolTable & symtab 
+) {
         // remove references from bound type, so that type variables can only bind to value types
-        bindTo = bindTo->stripReferences();
-        auto tyvar = openVars.find( typeInst->name );
-        assert( tyvar != openVars.end() );
-        if ( ! tyVarCompatible( tyvar->second, bindTo ) ) return false;
-        if ( occurs( bindTo, typeInst->name, *this ) ) return false;
+        ptr<Type> target = bindTo->stripReferences();
+        auto tyvar = open.find( typeInst->name );
+        assert( tyvar != open.end() );
+        if ( ! tyVarCompatible( tyvar->second, target ) ) return false;
+        if ( occurs( target, typeInst->name, *this ) ) return false;
 
         auto it = internal_lookup( typeInst->name );
@@ -282 +283 @@
                         // attempt to unify equivalence class type with type to bind to.
                         // equivalence class type has stripped qualifiers which must be restored
-                        const Type * common = nullptr;
+                        ptr<Type> common;
                         ptr<Type> newType = it->bound;
                         newType.get_and_mutate()->qualifiers = typeInst->qualifiers;
                         if ( unifyInexact( 
-                                        newType, bindTo, *this, need, have, openVars, 
-                                        widenMode & WidenMode{ it->allowWidening, true }, symtab, common ) ) {
+                                        newType, target, *this, need, have, open, 
+                                        widen & WidenMode{ it->allowWidening, true }, symtab, common ) ) {
                                 if ( common ) {
-                                        it->bound = common;
+                                        it->bound = std::move(common);
                                         clear_qualifiers( it->bound );
                                 }
                         } else return false;
                 } else {
-                        it->bound = bindTo;
+                        it->bound = std::move(target);
                         clear_qualifiers( it->bound );
-                        it->allowWidening = widenMode.widenFirst && widenMode.widenSecond;
+                        it->allowWidening = widen.first && widen.second;
                 }
         } else {
                 env.emplace_back( 
-                        typeInst->name, bindTo, widenMode.widenFirst && widenMode.widenSecond, data );
+                        typeInst->name, target, widen.first && widen.second, data );
         }
         return true;
@@ -307 +308 @@
 bool TypeEnvironment::bindVarToVar( 
                 const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, 
-                AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, 
-                WidenMode widenMode, const SymbolTable & symtab ) {
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, 
+                WidenMode widen, const SymbolTable & symtab 
+) {
         auto c1 = internal_lookup( var1->name );
         auto c2 = internal_lookup( var2->name );
@@ -314 +316 @@
         // exit early if variables already bound together
         if ( c1 != env.end() && c1 == c2 ) {
-                c1->allowWidening &= widenMode;
+                c1->allowWidening &= widen;
                 return true;
         }
@@ -327 +329 @@
                         type1 = c1->bound;
                 }
-                widen1 = widenMode.widenFirst && c1->allowWidening;
+                widen1 = widen.first && c1->allowWidening;
         }
         if ( c2 != env.end() ) {
@@ -334 +336 @@
                         type2 = c2->bound;
                 }
-                widen2 = widenMode.widenSecond && c2->allowWidening;
+                widen2 = widen.second && c2->allowWidening;
         }
 
@@ -341 +343 @@
                 ptr<Type> newType1{ type1 }, newType2{ type2 };
                 WidenMode newWidenMode{ widen1, widen2 };
-                const Type * common = nullptr;
+                ptr<Type> common;
 
                 if ( unifyInexact(
-                                newType1, newType2, *this, need, have, openVars, newWidenMode, symtab, common ) ) {
+                                newType1, newType2, *this, need, have, open, newWidenMode, symtab, common ) ) {
                         c1->vars.insert( c2->vars.begin(), c2->vars.end() );
                         c1->allowWidening = widen1 && widen2;
                         if ( common ) {
-                                c1->bound = common;
+                                c1->bound = std::move(common);
                                 clear_qualifiers( c1->bound );
                         }
@@ -395 +397 @@
 
 bool TypeEnvironment::mergeBound( 
-                EqvClass & to, const EqvClass & from, OpenVarSet & openVars, const SymbolTable & symtab ) {
+                EqvClass & to, const EqvClass & from, OpenVarSet & open, const SymbolTable & symtab ) {
         if ( from.bound ) {
                 if ( to.bound ) {
                         // attempt to unify bound types
                         ptr<Type> toType{ to.bound }, fromType{ from.bound };
-                        WidenMode widenMode{ to.allowWidening, from.allowWidening };
-                        const Type * common = nullptr;
+                        WidenMode widen{ to.allowWidening, from.allowWidening };
+                        ptr<Type> common;
                         AssertionSet need, have;
 
                         if ( unifyInexact( 
-                                        toType, fromType, *this, need, have, openVars, widenMode, symtab, common ) ) {
+                                        toType, fromType, *this, need, have, open, widen, symtab, common ) ) {
                                 // unifies, set common type if necessary
                                 if ( common ) {
-                                        to.bound = common;
+                                        to.bound = std::move(common);
                                         clear_qualifiers( to.bound );
                                 }
@@ -423 +425 @@
 
 bool TypeEnvironment::mergeClasses( 
-                ClassList::iterator to, ClassList::iterator from, OpenVarSet & openVars, 
-                const SymbolTable & symtab ) {
+        ClassList::iterator to, ClassList::iterator from, OpenVarSet & open, const SymbolTable & symtab
+) {
         EqvClass & r = *to, & s = *from;
 
         // ensure bounds match
-        if ( ! mergeBound( r, s, openVars, symtab ) ) return false;
+        if ( ! mergeBound( r, s, open, symtab ) ) return false;
 
         // check safely bindable

src/AST/TypeEnvironment.hpp

@@ -178 +178 @@
                 const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, 
                 AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, 
-                ResolvExpr::WidenMode widenMode, const SymbolTable & symtab );
+                ResolvExpr::WidenMode widen, const SymbolTable & symtab );
         
         /// Binds the type classes represented by `var1` and `var2` together; will add one or both 
@@ -185 +185 @@
                 const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, 
                 AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, 
-                ResolvExpr::WidenMode widenMode, const SymbolTable & symtab );
+                ResolvExpr::WidenMode widen, const SymbolTable & symtab );
 
         /// Disallows widening for all bindings in the environment

src/AST/porting.md

@@ -291 +291 @@
 * moved to be helper function in `TypeEnvironment.cpp` (its only use)
 
+`WidenMode`
+* changed `widenFirst`, `widenSecond` => `first`, `second`
+* changed `WidenMode widenMode` => `WidenMode widen`
+
 [1] https://gcc.gnu.org/onlinedocs/gcc-9.1.0/gcc/Type-Attributes.html#Type-Attributes