Changeset f57dd25 for src/ResolvExpr

Timestamp:

May 29, 2019, 3:45:00 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

0aedb01

Parents:

157a816 (diff), ebc0a85 (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 'cleanup-dtors'

File:

• src/ResolvExpr/Resolver.cc (modified) (9 diffs)

src/ResolvExpr/Resolver.cc

@@ -43 +43 @@
 #include "typeops.h"                     // for extractResultType
 #include "Unify.h"                       // for unify
+#include "Validate/FindSpecialDecls.h"   // for SizeType
 
 using namespace std;
@@ -235 +236 @@
                                 winner.cost = winner.cvtCost;
                         }
-                        
+
                         // produce ambiguous errors, if applicable
                         if ( winners.size() != 1 ) {
@@ -255 +256 @@
 
                         // xxx - check for ambiguous expressions
-                        
+
                         // output selected choice
                         alt = std::move( choice );
@@ -402 +403 @@
 
         void Resolver::previsit( ObjectDecl * objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
-                // class-variable initContext is changed multiple time because the LHS is analysed twice. 
-                // The second analysis changes initContext because of a function type can contain object 
-                // declarations in the return and parameter types. So each value of initContext is 
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
+                // class-variable initContext is changed multiple time because the LHS is analysed twice.
+                // The second analysis changes initContext because of a function type can contain object
+                // declarations in the return and parameter types. So each value of initContext is
                 // retained, so the type on the first analysis is preserved and used for selecting the RHS.
                 GuardValue( currentObject );
@@ -419 +420 @@
         void Resolver::handlePtrType( PtrType * type ) {
                 if ( type->get_dimension() ) {
-                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
+                        findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
                 }
         }
@@ -442 +443 @@
 
         void Resolver::postvisit( FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up 
+                // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
-                // xxx - it might be necessary to somehow keep the information from this environment, but I 
+                // xxx - it might be necessary to somehow keep the information from this environment, but I
                 // can't currently see how it's useful.
                 for ( Declaration * d : functionDecl->type->parameters ) {
@@ -795 +796 @@
                 initExpr->expr = nullptr;
                 std::swap( initExpr->env, newExpr->env );
-                // InitExpr may have inferParams in the case where the expression specializes a function 
-                // pointer, and newExpr may already have inferParams of its own, so a simple swap is not 
+                // InitExpr may have inferParams in the case where the expression specializes a function
+                // pointer, and newExpr may already have inferParams of its own, so a simple swap is not
                 // sufficient.
                 newExpr->spliceInferParams( initExpr );
                 delete initExpr;
 
-                // get the actual object's type (may not exactly match what comes back from the resolver 
+                // get the actual object's type (may not exactly match what comes back from the resolver
                 // due to conversions)
                 Type * initContext = currentObject.getCurrentType();
@@ -814 +815 @@
                                         if ( isCharType( pt->get_base() ) ) {
                                                 if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
-                                                        // strip cast if we're initializing a char[] with a char *, 
+                                                        // strip cast if we're initializing a char[] with a char *,
                                                         // e.g.  char x[] = "hello";
                                                         newExpr = ce->get_arg();
@@ -837 +838 @@
                 // move cursor into brace-enclosed initializer-list
                 currentObject.enterListInit();
-                // xxx - fix this so that the list isn't copied, iterator should be used to change current 
+                // xxx - fix this so that the list isn't copied, iterator should be used to change current
                 // element
                 std::list<Designation *> newDesignations;
                 for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
-                        // iterate designations and initializers in pairs, moving the cursor to the current 
+                        // iterate designations and initializers in pairs, moving the cursor to the current
                         // designated object and resolving the initializer against that object.
                         Designation * des = std::get<0>(p);