Changeset 2c57025 for src/ResolvExpr

Timestamp:

Nov 25, 2016, 6:11:03 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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, with_gc

Children:

0f35657

Parents:

186fd86

Message:

add support for built-in sized trait which decouples size/alignment information from otype parameters, add test for sized trait

Location:

src/ResolvExpr

Files:

• AdjustExprType.cc (modified) (1 diff)
• AlternativeFinder.cc (modified) (1 diff)
• CommonType.cc (modified) (3 diffs)
• FindOpenVars.cc (modified) (2 diffs)
• PtrsCastable.cc (modified) (3 diffs)
• TypeEnvironment.cc (modified) (4 diffs)
• TypeEnvironment.h (modified) (2 diffs)
• Unify.cc (modified) (10 diffs)

src/ResolvExpr/AdjustExprType.cc ¶

@@ -97 +97 @@
                 EqvClass eqvClass;
                 if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
-                        if ( eqvClass.kind == TypeDecl::Ftype ) {
+                        if ( eqvClass.data.kind == TypeDecl::Ftype ) {
                                 PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
                                 return pointerType;

src/ResolvExpr/AlternativeFinder.cc ¶

@@ -373 +373 @@
         void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
-                        unifiableVars[ (*tyvar)->get_name() ] = (*tyvar)->get_kind();
+                        unifiableVars[ (*tyvar)->get_name() ] = TypeDecl::Data{ *tyvar };
                         for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
                                 needAssertions[ *assert ] = true;

src/ResolvExpr/CommonType.cc ¶

@@ -57 +57 @@
                 Type *result = visitor.get_result();
                 if ( ! result ) {
+                        // this appears to be handling for opaque type declarations
                         if ( widenSecond ) {
-                                TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 );
-                                if ( inst ) {
-                                        NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
-                                        if ( nt ) {
-                                                TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
-                                                assert( type );
+                                if ( TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 ) ) {
+                                        if ( NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ) ) {
+                                                TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
                                                 if ( type->get_base() ) {
                                                         Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
@@ -145 +143 @@
         }
 
+        /// true if a common type for t must be a complete type
+        bool requiredComplete( Type * t ) {
+                if ( TypeInstType * inst = dynamic_cast< TypeInstType * > ( t ) ) {
+                        return inst->get_baseType()->isComplete();
+                }
+                return false;
+        }
+
         void CommonType::visit( PointerType *pointerType ) {
                 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
-                        if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base(), indexer) ) {
+                        // Note: relationship between formal and actual types is antisymmetric
+                        //   void free(void *);
+                        //   forall(otype T) void foo(T *);
+                        //
+                        // should be able to pass T* to free, but should not be able to pass a void* to foo.
+                        // because of this, the requiredComplete check occurs only on the first, since it corresponds
+                        // to the formal parameter type (though this may be incorrect in some cases, in which case
+                        // perhaps the widen mode needs to incorporate another bit for whether this is a formal or actual context)
+                        if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base(), indexer) && ! requiredComplete( pointerType->get_base() ) ) {
                                 result = otherPointer->clone();
                                 result->get_qualifiers() += pointerType->get_qualifiers();
@@ -211 +225 @@
                         NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
                         if ( nt ) {
-                                TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
-                                assert( type );
+                                TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
                                 if ( type->get_base() ) {
                                         Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers();

src/ResolvExpr/FindOpenVars.cc ¶

@@ -48 +48 @@
                 if ( nextIsOpen ) {
                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
-                                openVars[ (*i)->get_name() ] = (*i)->get_kind();
+                                openVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
                                         needAssertions[ *assert ] = false;
@@ -57 +57 @@
                 } else {
                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
-                                closedVars[ (*i)->get_name() ] = (*i)->get_kind();
+                                closedVars[ (*i)->get_name() ] = TypeDecl::Data{ (*i) };
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
                                         haveAssertions[ *assert ] = false;

src/ResolvExpr/PtrsCastable.cc ¶

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// PtrsCastable.cc -- 
+// PtrsCastable.cc --
 //
 // Author           : Richard C. Bilson
@@ -25 +25 @@
           public:
                 PtrsCastable( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
-  
+
                 int get_result() const { return result; }
 
@@ -61 +61 @@
                                 } //if
                         } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
-                                if ( eqvClass.kind == TypeDecl::Ftype ) {
+                                if ( eqvClass.data.kind == TypeDecl::Ftype ) {
                                         return -1;
                                 } // if

src/ResolvExpr/TypeEnvironment.cc ¶

@@ -94 +94 @@
                 dest.type = maybeClone( src.type );
                 dest.allowWidening = src.allowWidening;
-                dest.kind = src.kind;
+                dest.data = src.data;
         }
 
@@ -162 +162 @@
                         EqvClass newClass;
                         newClass.vars.insert( (*i)->get_name() );
-                        newClass.kind = (*i)->get_kind();
+                        newClass.data = TypeDecl::Data{ (*i) };
                         env.push_back( newClass );
                 } // for
@@ -177 +177 @@
                                         sub.add( *theVar, theClass->type );
                                 } else if ( theVar != theClass->vars.begin() ) {
-                                        TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->kind == TypeDecl::Ftype );
+                                        TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype );
 ///         std::cout << " bound to variable " << *theClass->vars.begin() << std::endl;
                                         sub.add( *theVar, newTypeInst );
@@ -243 +243 @@
                 for ( std::list< EqvClass >::const_iterator eqvClass = env.begin(); eqvClass != env.end(); ++eqvClass ) {
                         for ( std::set< std::string >::const_iterator var = eqvClass->vars.begin(); var != eqvClass->vars.end(); ++var ) {
-                                openVars[ *var ] = eqvClass->kind;
+                                openVars[ *var ] = eqvClass->data;
                         } // for
                 } // for

src/ResolvExpr/TypeEnvironment.h ¶

@@ -32 +32 @@
         };
         typedef std::map< DeclarationWithType*, bool, AssertCompare > AssertionSet;
-        typedef std::map< std::string, TypeDecl::Kind > OpenVarSet;
+        typedef std::map< std::string, TypeDecl::Data > OpenVarSet;
 
         void printAssertionSet( const AssertionSet &, std::ostream &, int indent = 0 );
@@ -41 +41 @@
                 Type *type;
                 bool allowWidening;
-                TypeDecl::Kind kind;
+                TypeDecl::Data data;
 
                 void initialize( const EqvClass &src, EqvClass &dest );

src/ResolvExpr/Unify.cc ¶

@@ -109 +109 @@
                 newFirst->get_qualifiers() = Type::Qualifiers();
                 newSecond->get_qualifiers() = Type::Qualifiers();
-///   std::cout << "first is ";
-///   first->print( std::cout );
-///   std::cout << std::endl << "second is ";
-///   second->print( std::cout );
-///   std::cout << std::endl << "newFirst is ";
-///   newFirst->print( std::cout );
-///   std::cout << std::endl << "newSecond is ";
-///   newSecond->print( std::cout );
-///   std::cout << std::endl;
+///   std::cerr << "first is ";
+///   first->print( std::cerr );
+///   std::cerr << std::endl << "second is ";
+///   second->print( std::cerr );
+///   std::cerr << std::endl << "newFirst is ";
+///   newFirst->print( std::cerr );
+///   std::cerr << std::endl << "newSecond is ";
+///   newSecond->print( std::cerr );
+///   std::cerr << std::endl;
                 bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                 delete newFirst;
@@ -133 +133 @@
         }
 
-        bool tyVarCompatible( TypeDecl::Kind kind, Type *type, const SymTab::Indexer &indexer ) {
-                switch ( kind ) {
+        struct CompleteTypeChecker : public Visitor {
+                virtual void visit( VoidType *basicType ) { status = false; }
+                virtual void visit( BasicType *basicType ) {}
+                virtual void visit( PointerType *pointerType ) {}
+                virtual void visit( ArrayType *arrayType ) { status = ! arrayType->get_isVarLen(); }
+                virtual void visit( FunctionType *functionType ) {}
+                virtual void visit( StructInstType *aggregateUseType ) { status = aggregateUseType->get_baseStruct()->has_body(); }
+                virtual void visit( UnionInstType *aggregateUseType ) { status = aggregateUseType->get_baseUnion()->has_body(); }
+                // xxx - enum inst does not currently contain a pointer to base, this should be fixed.
+                virtual void visit( EnumInstType *aggregateUseType ) { /* status = aggregateUseType->get_baseEnum()->hasBody(); */ }
+                virtual void visit( TraitInstType *aggregateUseType ) { assert( false ); }
+                virtual void visit( TypeInstType *aggregateUseType ) { status = aggregateUseType->get_baseType()->isComplete(); }
+                virtual void visit( TupleType *tupleType ) {} // xxx - not sure if this is right, might need to recursively check complete-ness
+                virtual void visit( TypeofType *typeofType ) { assert( false ); }
+                virtual void visit( AttrType *attrType ) { assert( false ); } // xxx - not sure what to do here
+                virtual void visit( VarArgsType *varArgsType ){} // xxx - is this right?
+                virtual void visit( ZeroType *zeroType ) {}
+                virtual void visit( OneType *oneType ) {}
+                bool status = true;
+        };
+        bool isComplete( Type * type ) {
+                CompleteTypeChecker checker;
+                assert( type );
+                type->accept( checker );
+                return checker.status;
+        }
+
+        bool tyVarCompatible( const TypeDecl::Data & data, Type *type, const SymTab::Indexer &indexer ) {
+                switch ( data.kind ) {
                   case TypeDecl::Any:
                   case TypeDecl::Dtype:
-                        return ! isFtype( type, indexer );
-
+                        // to bind to an object type variable, the type must not be a function type.
+                        // if the type variable is specified to be a complete type then the incoming
+                        // type must also be complete
+                        return ! isFtype( type, indexer ) && (! data.isComplete || isComplete( type ));
                   case TypeDecl::Ftype:
                         return isFtype( type, indexer );
@@ -146 +175 @@
         }
 
-        bool bindVar( TypeInstType *typeInst, Type *other, TypeDecl::Kind kind, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool bindVar( TypeInstType *typeInst, Type *other, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
                 OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
                 assert( tyvar != openVars.end() );
@@ -185 +214 @@
                         newClass.type->get_qualifiers() = Type::Qualifiers();
                         newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
-                        newClass.kind = kind;
+                        newClass.data = data;
                         env.add( newClass );
                 } // if
@@ -191 +220 @@
         }
 
-        bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Kind kind, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
                 bool result = true;
                 EqvClass class1, class2;
@@ -220 +249 @@
 
                 if ( type1 && type2 ) {
-//    std::cout << "has type1 && type2" << std::endl;
+//    std::cerr << "has type1 && type2" << std::endl;
                         WidenMode newWidenMode ( widen1, widen2 );
                         Type *common = 0;
@@ -258 +287 @@
                         newClass.vars.insert( var2->get_name() );
                         newClass.allowWidening = widen1 && widen2;
-                        newClass.kind = kind;
+                        newClass.data = data;
                         env.add( newClass );
                 } // if
@@ -321 +350 @@
                 } // if
 #ifdef DEBUG
-                std::cout << "============ unifyExact" << std::endl;
-                std::cout << "type1 is ";
-                type1->print( std::cout );
-                std::cout << std::endl << "type2 is ";
-                type2->print( std::cout );
-                std::cout << std::endl << "openVars are ";
-                printOpenVarSet( openVars, std::cout, 8 );
-                std::cout << std::endl << "input env is " << std::endl;
-                debugEnv.print( std::cout, 8 );
-                std::cout << std::endl << "result env is " << std::endl;
-                env.print( std::cout, 8 );
-                std::cout << "result is " << result << std::endl;
+                std::cerr << "============ unifyExact" << std::endl;
+                std::cerr << "type1 is ";
+                type1->print( std::cerr );
+                std::cerr << std::endl << "type2 is ";
+                type2->print( std::cerr );
+                std::cerr << std::endl << "openVars are ";
+                printOpenVarSet( openVars, std::cerr, 8 );
+                std::cerr << std::endl << "input env is " << std::endl;
+                debugEnv.print( std::cerr, 8 );
+                std::cerr << std::endl << "result env is " << std::endl;
+                env.print( std::cerr, 8 );
+                std::cerr << "result is " << result << std::endl;
 #endif
                 return result;
@@ -347 +376 @@
                 bool result;
 #ifdef DEBUG
-                std::cout << "unifyInexact type 1 is ";
-                type1->print( std::cout );
-                std::cout << "type 2 is ";
-                type2->print( std::cout );
-                std::cout << std::endl;
+                std::cerr << "unifyInexact type 1 is ";
+                type1->print( std::cerr );
+                std::cerr << "type 2 is ";
+                type2->print( std::cerr );
+                std::cerr << std::endl;
 #endif
                 if ( ! unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer ) ) {
 #ifdef DEBUG
-                        std::cout << "unifyInexact: no exact unification found" << std::endl;
+                        std::cerr << "unifyInexact: no exact unification found" << std::endl;
 #endif
                         if ( ( common = commonType( type1, type2, widenMode.widenFirst, widenMode.widenSecond, indexer, env, openVars ) ) ) {
                                 common->get_qualifiers() = tq1 + tq2;
 #ifdef DEBUG
-                                std::cout << "unifyInexact: common type is ";
-                                common->print( std::cout );
-                                std::cout << std::endl;
+                                std::cerr << "unifyInexact: common type is ";
+                                common->print( std::cerr );
+                                std::cerr << std::endl;
 #endif
                                 result = true;
                         } else {
 #ifdef DEBUG
-                                std::cout << "unifyInexact: no common type found" << std::endl;
+                                std::cerr << "unifyInexact: no common type found" << std::endl;
 #endif
                                 result = false;
@@ -404 +433 @@
 
         void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) {
-///   std::cout << "assertion set is" << std::endl;
-///   printAssertionSet( assertions, std::cout, 8 );
-///   std::cout << "looking for ";
-///   assert->print( std::cout );
-///   std::cout << std::endl;
+///   std::cerr << "assertion set is" << std::endl;
+///   printAssertionSet( assertions, std::cerr, 8 );
+///   std::cerr << "looking for ";
+///   assert->print( std::cerr );
+///   std::cerr << std::endl;
                 AssertionSet::iterator i = assertions.find( assert );
                 if ( i != assertions.end() ) {
-///     std::cout << "found it!" << std::endl;
+///     std::cerr << "found it!" << std::endl;
                         i->second = true;
                 } // if