Changes in / [2a301ff:686912c]

Location:

src

Files:

• Parser/parser.yy (modified) (3 diffs)
• ResolvExpr/CurrentObject.cc (modified) (2 diffs)
• ResolvExpr/ResolveTypeof.cc (modified) (9 diffs)
• ResolvExpr/ResolveTypeof.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• Validate/GenericParameter.cpp (modified) (1 diff)

src/Parser/parser.yy

@@ -2691 +2691 @@
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
                 {
-                        if ( $3 && ($3->storageClasses.any() || $3->type->qualifiers.val != 0 )) {
+                        if ( $3->storageClasses.any() || $3->type->qualifiers.val != 0 ) {
                                 SemanticError( yylloc, "syntax error, storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." );
                         }
@@ -2829 +2829 @@
 
 cfa_abstract_parameter_declaration:                                             // CFA, new & old style parameter declaration
-        // empty
-                { $$ = nullptr; }
-        | abstract_parameter_declaration
+        abstract_parameter_declaration
         | cfa_identifier_parameter_declarator_no_tuple
         | cfa_abstract_tuple
@@ -3856 +3854 @@
                 // { SemanticError( yylloc, "New array dimension is currently unimplemented." ); $$ = nullptr; }
         | '[' push array_type_list pop ']'                                      // CFA
-                { $$ = DeclarationNode::newArray( $3, nullptr, false ); }
+                { SemanticError( yylloc, "Type array dimension is currently unimplemented." ); $$ = nullptr; }
         | multi_array_dimension
         ;

src/ResolvExpr/CurrentObject.cc

@@ -1045 +1045 @@
                         PRINT( std::cerr << "____untyped: " << expr << std::endl; )
                         auto dit = desigAlts.begin();
-
-                        for ( const Type * t : curTypes ) {
-                                assert( dit != desigAlts.end() );
-                                DesignatorChain & d = *dit;
-                                if ( auto nexpr = dynamic_cast< const NameExpr *>( expr ) ) {
+                        if ( auto nexpr = dynamic_cast< const NameExpr * >( expr ) ) {
+                                for ( const Type * t : curTypes ) {
+                                        assert( dit != desigAlts.end() );
+
+                                        DesignatorChain & d = *dit;
                                         PRINT( std::cerr << "____actual: " << t << std::endl; )
                                         if ( auto refType = dynamic_cast< const BaseInstType * >( t ) ) {
@@ -1062 +1062 @@
                                                         }
                                                 }
-                                        } else if ( auto at = dynamic_cast< const ArrayType * >( t ) ) {
-                                                auto nexpr = dynamic_cast< const NameExpr *>( expr );
-                                                auto res = eval( nexpr ); 
-                                                for ( const Decl * mem : refType->lookup( nexpr->name ) ) {
-                                                        if ( auto field = dynamic_cast< const ObjectDecl * >( mem ) ) {
-                                                                DesignatorChain d2 = d;
-                                                                d2.emplace_back( new VariableExpr{ expr->location, field } );
-                                                                newDesigAlts.emplace_back( std::move( d2 ) );
-                                                                // newTypes.emplace_back( field->type );
-                                                                newTypes.emplace_back( at->base );
-                                                        }
-                                                }
-
-                                                // d.emplace_back( expr );
-                                                // newDesigAlts.emplace_back( d );
-                                                // newTypes.emplace_back( at->base );
                                         }
 
                                         ++dit;
-                                } else {
+                                }
+                        } else {
+                                for ( const Type * t : curTypes ) {
+                                        assert( dit != desigAlts.end() );
+
+                                        DesignatorChain & d = *dit;
                                         if ( auto at = dynamic_cast< const ArrayType * >( t ) ) {
                                                 PRINT( std::cerr << "____alt: " << at->get_base() << std::endl; )

src/ResolvExpr/ResolveTypeof.cc

@@ -15 +15 @@
 
 #include "ResolveTypeof.h"
-
-#include <cassert>  // for assert
+#include "RenameVars.h"
+
+#include <cassert>               // for assert
 
 #include "AST/CVQualifiers.hpp"
@@ -24 +25 @@
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"   // for PassVisitor
-#include "Common/utility.h"       // for copy
-#include "InitTweak/InitTweak.h"  // for isConstExpr
-#include "RenameVars.h"
-#include "Resolver.h"  // for resolveInVoidContext
-#include "SymTab/Mangler.h"
+#include "Common/PassVisitor.h"  // for PassVisitor
+#include "Common/utility.h"      // for copy
+#include "Resolver.h"            // for resolveInVoidContext
 #include "SynTree/Expression.h"  // for Expression
 #include "SynTree/Mutator.h"     // for Mutator
 #include "SynTree/Type.h"        // for TypeofType, Type
+#include "SymTab/Mangler.h"
+#include "InitTweak/InitTweak.h" // for isConstExpr
 
 namespace SymTab {
@@ -39 +39 @@
 
 namespace ResolvExpr {
-namespace {
+        namespace {
 #if 0
                 void
@@ -52 +52 @@
         }
 
-class ResolveTypeof_old : public WithShortCircuiting {
-   public:
+        class ResolveTypeof_old : public WithShortCircuiting {
+          public:
                 ResolveTypeof_old( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
                 void premutate( TypeofType *typeofType );
                 Type * postmutate( TypeofType *typeofType );
 
-   private:
-    const SymTab::Indexer &indexer;
-};
+          private:
+                const SymTab::Indexer &indexer;
+        };
 
         Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
@@ -71 +71 @@
         }
 
-    Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) {
+        Type * ResolveTypeof_old::postmutate( TypeofType *typeofType ) {
 #if 0
                 std::cerr << "resolving typeof: ";
@@ -77 +77 @@
                 std::cerr << std::endl;
 #endif
-    // pass on null expression
+                // pass on null expression
                 if ( ! typeofType->expr ) return typeofType;
 
-    bool isBasetypeof = typeofType->is_basetypeof;
-    auto oldQuals = typeofType->get_qualifiers().val;
-
-    Type* newType;
+                bool isBasetypeof = typeofType->is_basetypeof;
+                auto oldQuals = typeofType->get_qualifiers().val;
+
+                Type* newType;
                 if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(typeofType->expr) ) {
-        // typeof wrapping type
-        newType = tyExpr->type;
-        tyExpr->type = nullptr;
-        delete tyExpr;
-    } else {
-        // typeof wrapping expression
+                        // typeof wrapping type
+                        newType = tyExpr->type;
+                        tyExpr->type = nullptr;
+                        delete tyExpr;
+                } else {
+                        // typeof wrapping expression
                         Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
                         assert( newExpr->result && ! newExpr->result->isVoid() );
-        newType = newExpr->result;
-        newExpr->result = nullptr;
-        delete typeofType;
-        delete newExpr;
-    }
-
-    // clear qualifiers for base, combine with typeoftype quals in any case
-    if ( isBasetypeof ) {
+                        newType = newExpr->result;
+                        newExpr->result = nullptr;
+                        delete typeofType;
+                        delete newExpr;
+                }
+
+                // clear qualifiers for base, combine with typeoftype quals in any case
+                if ( isBasetypeof ) {
                         // replace basetypeof(<enum>) by int
                         if ( dynamic_cast<EnumInstType*>(newType) ) {
@@ -112 +112 @@
                                 = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
                 } else {
-        newType->get_qualifiers().val |= oldQuals;
-    }
-
-    return newType;
-}
+                        newType->get_qualifiers().val |= oldQuals;
+                }
+
+                return newType;
+        }
 
 namespace {
-struct ResolveTypeof_new : public ast::WithShortCircuiting {
-    const ResolveContext & context;
+        struct ResolveTypeof_new : public ast::WithShortCircuiting {
+                const ResolveContext & context;
 
                 ResolveTypeof_new( const ResolveContext & context ) :
@@ -127 +127 @@
                 void previsit( const ast::TypeofType * ) { visit_children = false; }
 
-        const ast::Type * postvisit( const ast::TypeofType * typeofType ) {
-        // pass on null expression
-            if ( ! typeofType->expr ) return typeofType;
-
-            ast::ptr< ast::Type > newType;
-            if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) {
-            // typeof wrapping type
-            newType = tyExpr->type;
-        } else {
-            // typeof wrapping expression
-            ast::TypeEnvironment dummy;
-            ast::ptr< ast::Expr > newExpr =
-                resolveInVoidContext( typeofType->expr, context, dummy );
-            assert( newExpr->result && ! newExpr->result->isVoid() );
-            newType = newExpr->result;
-        }
-
-        // clear qualifiers for base, combine with typeoftype quals regardless
-        if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
-            // replace basetypeof(<enum>) by int
+                const ast::Type * postvisit( const ast::TypeofType * typeofType ) {
+                        // pass on null expression
+                        if ( ! typeofType->expr ) return typeofType;
+
+                        ast::ptr< ast::Type > newType;
+                        if ( auto tyExpr = typeofType->expr.as< ast::TypeExpr >() ) {
+                                // typeof wrapping type
+                                newType = tyExpr->type;
+                        } else {
+                                // typeof wrapping expression
+                                ast::TypeEnvironment dummy;
+                                ast::ptr< ast::Expr > newExpr =
+                                        resolveInVoidContext( typeofType->expr, context, dummy );
+                                assert( newExpr->result && ! newExpr->result->isVoid() );
+                                newType = newExpr->result;
+                        }
+
+                        // clear qualifiers for base, combine with typeoftype quals regardless
+                        if ( typeofType->kind == ast::TypeofType::Basetypeof ) {
+                                // replace basetypeof(<enum>) by int
                                 if ( newType.as< ast::EnumInstType >() ) {
                                         newType = new ast::BasicType{
                                                 ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) };
-            }
+                                }
                                 reset_qualifiers(
                                         newType,
                                         ( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers );
-        } else {
+                        } else {
                                 add_qualifiers( newType, typeofType->qualifiers );
-        }
-
-        return newType.release();
-    }
-};
+                        }
+
+                        return newType.release();
+                }
+        };
 } // anonymous namespace
 
@@ -195 +195 @@
 
 const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & context ) {
-    if (decl->isTypeFixed) {
-        return decl;
-    }
-
-    auto mutDecl = mutate(decl);
-    fixObjectInit(decl, context);
-    {
-        auto resolvedType = resolveTypeof(decl->type, context);
-        resolvedType = fixArrayType(resolvedType, context);
-        mutDecl->type = resolvedType;
-    }
-
-    // Do not mangle unnamed variables.
-    if (!mutDecl->name.empty()) {
-        mutDecl->mangleName = Mangle::mangle(mutDecl);
-    }
-
-    mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
-    mutDecl->isTypeFixed = true;
-    return mutDecl;
+        if (decl->isTypeFixed) {
+                return decl;
+        }
+
+        auto mutDecl = mutate(decl);
+        {
+                auto resolvedType = resolveTypeof(decl->type, context);
+                resolvedType = fixArrayType(resolvedType, context);
+                mutDecl->type = resolvedType;
+        }
+
+        // Do not mangle unnamed variables.
+        if (!mutDecl->name.empty()) {
+                mutDecl->mangleName = Mangle::mangle(mutDecl);
+        }
+
+        mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
+        mutDecl->isTypeFixed = true;
+        return mutDecl;
 }
 
-const ast::ObjectDecl *fixObjectInit(const ast::ObjectDecl *decl,
-                                     const ResolveContext &context) {
-    if (decl->isTypeFixed) {
-        return decl;
-    }
-
-    auto mutDecl = mutate(decl);
-
-    if ( auto mutListInit = mutDecl->init.as<ast::ListInit>() ) {
-        // std::list<ast::Designation *> newDesignations;        
-
-        for ( size_t k = 0; k < mutListInit->designations.size(); k++ ) {
-            const ast::Designation *des = mutListInit->designations[k].get();
-            // Desination here
-            ast::Designation * newDesination = new ast::Designation(des->location);
-
-            if (des->designators.size() == 0) continue;
-
-            // The designator I want to replace
-            const ast::Expr * designator = des->designators.at(0);
-
-            if ( const ast::NameExpr * designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
-                auto candidates = context.symtab.lookupId(designatorName->name);
-                // Does not work for the overloading case currently
-                // assert( candidates.size() == 1 );
-                if ( candidates.size() != 1 ) return mutDecl;
-                auto candidate = candidates.at(0);
-                if ( const ast::EnumInstType * enumInst = dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type()) ) {
-                    // determine that is an enumInst, swap it with its const value
-                    assert( candidates.size() == 1 );
-                    const ast::EnumDecl * baseEnum = enumInst->base;
-                    // Need to iterate over all enum value to find the initializer to swap
-                    for ( size_t m = 0; m < baseEnum->members.size(); ++m ) {
-                        if ( baseEnum->members.at(m)->name == designatorName->name ) {
-                            const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
-                            assert(mem);
-                            if ( mem->init ) {
-                                const ast::SingleInit * memInit = mem->init.as<const ast::SingleInit>();
-                                ast::Expr * initValue = shallowCopy( memInit->value.get() );
-                                newDesination->designators.push_back( initValue );
-                            } else {
-                                SemanticError(des->location, "TODO: Enum Array Designation with no explicit value is not implemented");
-                            }
-                        }
-                    }
-                    if ( newDesination->designators.size() == 0 ) {
-                        SemanticError(des->location, "Resolution Error: Resolving array designation as Enum Instance value, but cannot find a desgination value");
-                    }
-                } else {
-                    newDesination->designators.push_back( des->designators.at(0) );
-                }
-            } else {
-                newDesination->designators.push_back( des->designators.at(0) );
-            }
-            mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
-        }
-    }
-    return mutDecl;
-}
-
-}  // namespace ResolvExpr
+} // namespace ResolvExpr
 
 // Local Variables: //

src/ResolvExpr/ResolveTypeof.h

@@ -32 +32 @@
         const ast::Type * fixArrayType( const ast::Type *, const ResolveContext & );
         const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & );
-        const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext &);
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -1507 +1507 @@
                                 if ( InitTweak::tryConstruct( mutDecl ) && ( managedTypes.isManaged( mutDecl ) || ((! isInFunction() || mutDecl->storage.is_static ) && ! InitTweak::isConstExpr( mutDecl->init ) ) ) ) {
                                         // constructed objects cannot be designated
-                                        // if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
-                                        if ( InitTweak::isDesignated( mutDecl->init ) ) {
-                                                SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
-                                        }
+                                        if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
                                         // constructed objects should not have initializers nested too deeply
                                         if ( ! InitTweak::checkInitDepth( mutDecl ) ) SemanticError( mutDecl, "Managed object's initializer is too deep " );

src/Validate/GenericParameter.cpp

@@ -301 +301 @@
 const ast::Expr * TranslateDimensionCore::postvisit(
                 const ast::TypeExpr * expr ) {
-        if ( auto instType = dynamic_cast<const ast::EnumInstType *>( expr->type.get() ) ) {
-                const ast::EnumDecl * baseEnum = instType->base.get();
-                return ast::ConstantExpr::from_int( expr->location, baseEnum->members.size() );
-        }
+        // Does nothing, except prevents matching ast::Expr (above).
         return expr;
 }