Changeset 579263a for src/ResolvExpr

Timestamp:

Jun 26, 2017, 4:48:35 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:

bb1cd95

Parents:

e4d829b (diff), 2a7b3ca (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' into designations

Conflicts:

src/InitTweak/FixInit.cc
src/SymTab/Autogen.h
src/SynTree/Initializer.cc
src/SynTree/Initializer.h
src/Tuples/TupleExpansion.cc

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (2 diffs)
• CommonType.cc (modified) (1 diff)
• PtrsCastable.cc (modified) (1 diff)
• Unify.cc (modified) (7 diffs)
• typeops.h (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -97 +97 @@
                 /// Prunes a list of alternatives down to those that have the minimum conversion cost for a given return type; skips ambiguous interpretations
                 template< typename InputIterator, typename OutputIterator >
-                void pruneAlternatives( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer ) {
+                void pruneAlternatives( InputIterator begin, InputIterator end, OutputIterator out ) {
                         // select the alternatives that have the minimum conversion cost for a particular set of result types
                         std::map< std::string, PruneStruct > selected;
@@ -183 +183 @@
                         )
                         AltList::iterator oldBegin = alternatives.begin();
-                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
+                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) );
                         if ( alternatives.begin() == oldBegin ) {
                                 std::ostringstream stream;

src/ResolvExpr/CommonType.cc

@@ -157 +157 @@
         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) ) {
+                        if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) {
                                 getCommonWithVoidPointer( otherPointer, pointerType );
-                        } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base(), indexer) ) {
+                        } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base()) ) {
                                 getCommonWithVoidPointer( pointerType, otherPointer );
                         } else if ( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst )

src/ResolvExpr/PtrsCastable.cc

@@ -135 +135 @@
         }
 
-        void PtrsCastable::visit(TraitInstType *inst) {
-                // I definitely don't think we should be doing anything here
-        }
+        void PtrsCastable::visit( __attribute__((unused)) TraitInstType *inst ) {}
 
         void PtrsCastable::visit(TypeInstType *inst) {

src/ResolvExpr/Unify.cc

@@ -114 +114 @@
         }
 
-        bool isFtype( Type *type, const SymTab::Indexer &indexer ) {
+        bool isFtype( Type *type ) {
                 if ( dynamic_cast< FunctionType* >( type ) ) {
                         return true;
@@ -123 +123 @@
         }
 
-        bool tyVarCompatible( const TypeDecl::Data & data, Type *type, const SymTab::Indexer &indexer ) {
+        bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
                 switch ( data.kind ) {
                   case TypeDecl::Any:
@@ -131 +131 @@
                         // type must also be complete
                         // xxx - should this also check that type is not a tuple type and that it's not a ttype?
-                        return ! isFtype( type, indexer ) && (! data.isComplete || type->isComplete() );
+                        return ! isFtype( type ) && (! data.isComplete || type->isComplete() );
                   case TypeDecl::Ftype:
-                        return isFtype( type, indexer );
+                        return isFtype( type );
                   case TypeDecl::Ttype:
                         // ttype unifies with any tuple type
@@ -144 +144 @@
                 OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
                 assert( tyvar != openVars.end() );
-                if ( ! tyVarCompatible( tyvar->second, other, indexer ) ) {
+                if ( ! tyVarCompatible( tyvar->second, other ) ) {
                         return false;
                 } // if
@@ -388 +388 @@
         }
 
-        void Unify::visit(VoidType *voidType) {
+        void Unify::visit( __attribute__((unused)) VoidType *voidType) {
                 result = dynamic_cast< VoidType* >( type2 );
         }
@@ -683 +683 @@
 
         template< typename Iterator1, typename Iterator2 >
-        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 auto get_type = [](Type * t) { return t; };
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
@@ -733 +733 @@
                         flatten( flat2.get(), back_inserter( types2 ) );
 
-                        result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, widenMode, indexer );
-                } // if
-        }
-
-        void Unify::visit(VarArgsType *varArgsType) {
+                        result = unifyList( types1.begin(), types1.end(), types2.begin(), types2.end(), env, needAssertions, haveAssertions, openVars, indexer );
+                } // if
+        }
+
+        void Unify::visit( __attribute__((unused)) VarArgsType *varArgsType ) {
                 result = dynamic_cast< VarArgsType* >( type2 );
         }
 
-        void Unify::visit(ZeroType *zeroType) {
+        void Unify::visit( __attribute__((unused)) ZeroType *zeroType ) {
                 result = dynamic_cast< ZeroType* >( type2 );
         }
 
-        void Unify::visit(OneType *oneType) {
+        void Unify::visit( __attribute__((unused)) OneType *oneType ) {
                 result = dynamic_cast< OneType* >( type2 );
         }

src/ResolvExpr/typeops.h

@@ -118 +118 @@
 
         // in Unify.cc
-        bool isFtype( Type *type, const SymTab::Indexer &indexer );
+        bool isFtype( Type *type );
         bool typesCompatible( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
         bool typesCompatibleIgnoreQualifiers( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );