Changeset 490ff5c3

Timestamp:

Feb 14, 2018, 1:54:14 PM (7 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:

44b4114

Parents:

54c9000

git-author:

Rob Schluntz <rschlunt@…> (02/14/18 12:00:25)

git-committer:

Rob Schluntz <rschlunt@…> (02/14/18 13:54:14)

Message:

Minor code cleanup

Location:

src

Files:

• ResolvExpr/AlternativeFinder.cc (modified) (6 diffs)
• SymTab/Indexer.cc (modified) (2 diffs)
• SymTab/Indexer.h (modified) (1 diff)
• Tuples/Explode.h (modified) (7 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -1380 +1380 @@
         void AlternativeFinder::Finder::postvisit( NameExpr *nameExpr ) {
                 std::list< SymTab::Indexer::IdData > declList;
-                indexer.lookupId( nameExpr->get_name(), declList );
-                PRINT( std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl; )
+                indexer.lookupId( nameExpr->name, declList );
+                PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
                 for ( auto & data : declList ) {
                         Expression * newExpr = data.combine();
@@ -1402 +1402 @@
                 // not sufficient to clone here, because variable's type may have changed
                 // since the VariableExpr was originally created.
-                alternatives.push_back( Alternative( new VariableExpr( variableExpr->get_var() ), env, Cost::zero ) );
+                alternatives.push_back( Alternative( new VariableExpr( variableExpr->var ), env, Cost::zero ) );
         }
 
@@ -1469 +1469 @@
                 // xxx - resolveTypeof?
                 if ( StructInstType *structInst = dynamic_cast< StructInstType* >( offsetofExpr->get_type() ) ) {
-                        addOffsetof( structInst, offsetofExpr->get_member() );
+                        addOffsetof( structInst, offsetofExpr->member );
                 } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( offsetofExpr->get_type() ) ) {
-                        addOffsetof( unionInst, offsetofExpr->get_member() );
+                        addOffsetof( unionInst, offsetofExpr->member );
                 }
         }
@@ -1548 +1548 @@
                 secondFinder.findWithAdjustment( logicalExpr->get_arg2() );
                 if ( secondFinder.alternatives.empty() ) return;
-                for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
-                        for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
+                for ( const Alternative & first : firstFinder.alternatives ) {
+                        for ( const Alternative & second : secondFinder.alternatives ) {
                                 TypeEnvironment compositeEnv;
-                                compositeEnv.simpleCombine( first->env );
-                                compositeEnv.simpleCombine( second->env );
-
-                                LogicalExpr *newExpr = new LogicalExpr( first->expr->clone(), second->expr->clone(), logicalExpr->get_isAnd() );
-                                alternatives.push_back( Alternative( newExpr, compositeEnv, first->cost + second->cost ) );
+                                compositeEnv.simpleCombine( first.env );
+                                compositeEnv.simpleCombine( second.env );
+
+                                LogicalExpr *newExpr = new LogicalExpr( first.expr->clone(), second.expr->clone(), logicalExpr->get_isAnd() );
+                                alternatives.push_back( Alternative( newExpr, compositeEnv, first.cost + second.cost ) );
                         }
                 }
@@ -1605 +1605 @@
                 AlternativeFinder secondFinder( indexer, newEnv );
                 secondFinder.findWithAdjustment( commaExpr->get_arg2() );
-                for ( AltList::const_iterator alt = secondFinder.alternatives.begin(); alt != secondFinder.alternatives.end(); ++alt ) {
-                        alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt->expr->clone() ), alt->env, alt->cost ) );
+                for ( const Alternative & alt : secondFinder.alternatives ) {
+                        alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt.expr->clone() ), alt.env, alt.cost ) );
                 } // for
                 delete newFirstArg;
@@ -1614 +1614 @@
                 // resolve low and high, accept alternatives whose low and high types unify
                 AlternativeFinder firstFinder( indexer, env );
-                firstFinder.findWithAdjustment( rangeExpr->get_low() );
+                firstFinder.findWithAdjustment( rangeExpr->low );
                 if ( firstFinder.alternatives.empty() ) return;
                 AlternativeFinder secondFinder( indexer, env );
-                secondFinder.findWithAdjustment( rangeExpr->get_high() );
+                secondFinder.findWithAdjustment( rangeExpr->high );
                 if ( secondFinder.alternatives.empty() ) return;
-                for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
-                        for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
+                for ( const Alternative & first : firstFinder.alternatives ) {
+                        for ( const Alternative & second : secondFinder.alternatives ) {
                                 TypeEnvironment compositeEnv;
-                                compositeEnv.simpleCombine( first->env );
-                                compositeEnv.simpleCombine( second->env );
+                                compositeEnv.simpleCombine( first.env );
+                                compositeEnv.simpleCombine( second.env );
                                 OpenVarSet openVars;
                                 AssertionSet needAssertions, haveAssertions;
-                                Alternative newAlt( 0, compositeEnv, first->cost + second->cost );
+                                Alternative newAlt( 0, compositeEnv, first.cost + second.cost );
                                 Type* commonType = nullptr;
-                                if ( unify( first->expr->get_result(), second->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
-                                        RangeExpr *newExpr = new RangeExpr( first->expr->clone(), second->expr->clone() );
-                                        newExpr->set_result( commonType ? commonType : first->expr->get_result()->clone() );
+                                if ( unify( first.expr->result, second.expr->result, newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
+                                        RangeExpr * newExpr = new RangeExpr( first.expr->clone(), second.expr->clone() );
+                                        newExpr->result = commonType ? commonType : first.expr->result->clone();
                                         newAlt.expr = newExpr;
                                         inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );

src/SymTab/Indexer.cc

@@ -434 +434 @@
                         }
                 } else {
-                        // Check that a Cforall declaration doesn't overload any C declaration
+                        // Check that a Cforall declaration doesn't override any C declaration
                         if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
                                 throw SemanticError( "Cforall declaration hides C function ", decl );
@@ -654 +654 @@
 
         void Indexer::print( std::ostream &os, int indent ) const {
-            using std::cerr;
+                using std::cerr;
 
                 if ( tables ) {

src/SymTab/Indexer.h

@@ -40 +40 @@
 
                 struct IdData {
-                        DeclarationWithType * id;
-                        Expression * baseExpr; // WithExpr
+                        DeclarationWithType * id = nullptr;
+                        Expression * baseExpr = nullptr; // WithExpr
+
+                        /// non-null if this declaration is deleted
+                        BaseSyntaxNode * deleteStmt = nullptr;
 
                         Expression * combine() const;

src/Tuples/Explode.h

@@ -43 +43 @@
         /// Append alternative to an OutputIterator of Alternatives
         template<typename OutputIterator>
-        void append( OutputIterator out, Expression* expr, const ResolvExpr::TypeEnvironment& env, 
+        void append( OutputIterator out, Expression* expr, const ResolvExpr::TypeEnvironment& env,
                         const ResolvExpr::Cost& cost, const ResolvExpr::Cost& cvtCost ) {
                 *out++ = ResolvExpr::Alternative{ expr, env, cost, cvtCost };
@@ -49 +49 @@
 
         /// Append alternative to an ExplodedActual
-        static inline void append( ResolvExpr::ExplodedActual& ea, Expression* expr, 
+        static inline void append( ResolvExpr::ExplodedActual& ea, Expression* expr,
                         const ResolvExpr::TypeEnvironment&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
                 ea.exprs.emplace_back( expr );
@@ -57 +57 @@
         /// helper function used by explode
         template< typename Output >
-        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, 
+        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt,
                         const SymTab::Indexer & indexer, Output&& out, bool isTupleAssign ) {
                 if ( isTupleAssign ) {
@@ -63 +63 @@
                         if ( CastExpr * castExpr = isReferenceCast( expr ) ) {
                                 ResolvExpr::AltList alts;
-                                explodeUnique( 
+                                explodeUnique(
                                         castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
                                 for ( ResolvExpr::Alternative & alt : alts ) {
                                         // distribute reference cast over all components
-                                        append( std::forward<Output>(out), distributeReference( alt.release_expr() ), 
+                                        append( std::forward<Output>(out), distributeReference( alt.release_expr() ),
                                                 alt.env, alt.cost, alt.cvtCost );
                                 }
@@ -108 +108 @@
         /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
         template< typename Output >
-        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, 
+        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer,
                         Output&& out, bool isTupleAssign = false ) {
                 explodeUnique( alt.expr, alt, indexer, std::forward<Output>(out), isTupleAssign );
@@ -115 +115 @@
         // explode list of alternatives
         template< typename AltIterator, typename Output >
-        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, 
+        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer,
                         Output&& out, bool isTupleAssign = false ) {
                 for ( ; altBegin != altEnd; ++altBegin ) {
@@ -123 +123 @@
 
         template< typename Output >
-        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, Output&& out, 
+        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, Output&& out,
                         bool isTupleAssign = false ) {
                 explode( alts.begin(), alts.end(), indexer, std::forward<Output>(out), isTupleAssign );