Changeset 4894239 for src

Timestamp:

Sep 6, 2023, 3:44:19 PM (17 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

f3f009f

Parents:

1fc111c

Message:

Allow uninitialized enum value as designators

Location:

src/ResolvExpr

Files:

• ResolveTypeof.cc (modified) (4 diffs)
• Resolver.cc (modified) (2 diffs)

src/ResolvExpr/ResolveTypeof.cc

@@ -237 +237 @@
             // The designator I want to replace
             const ast::Expr * designator = des->designators.at(0);
-
+            // Stupid flag variable for development, to be removed
+            bool mutated = false;
             if ( const ast::NameExpr * designatorName = dynamic_cast<const ast::NameExpr *>(designator) ) {
                 auto candidates = context.symtab.lookupId(designatorName->name);
@@ -244 +245 @@
                 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()) ) {
+                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 );
@@ -250 +251 @@
                     // Need to iterate over all enum value to find the initializer to swap
                     for ( size_t m = 0; m < baseEnum->members.size(); ++m ) {
+                        const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
                         if ( baseEnum->members.at(m)->name == designatorName->name ) {
-                            const ast::ObjectDecl * mem = baseEnum->members.at(m).as<const ast::ObjectDecl>();
                             assert(mem);
-                            const ast::ConstantExpr * enumAsInit = ast::ConstantExpr::from_int(newDesination->location, m);
-                            newDesination->designators.push_back( enumAsInit );
+                            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 );
+                                mutated = true;
+                            }
+                            break;
                         }
-                    }
-                    if ( newDesination->designators.size() == 0 ) {
-                        SemanticError(des->location, "Resolution Error: Resolving array designation as Enum Instance value, but cannot find a desgination value");
                     }
                 } else {
@@ -266 +269 @@
                 newDesination->designators.push_back( des->designators.at(0) );
             }
-            mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
+            if ( mutated ) {
+                mutListInit = ast::mutate_field_index(mutListInit, &ast::ListInit::designations, k, newDesination);
+            }
         }
     }

src/ResolvExpr/Resolver.cc

@@ -988 +988 @@
                         }
                 };
+
+                struct ResolveDesignators_new final : public ast::WithShortCircuiting {
+                        ResolveContext& context;
+                        bool result = false;
+
+                        ResolveDesignators_new( ResolveContext& _context ): context{_context} {};
+
+                        void previsit( const ast::Node * ) {
+                                // short circuit if we already know there are designations
+                                if ( result ) visit_children = false;
+                        }
+
+                        void previsit( const ast::Designation * des ) {
+                                if ( result ) visit_children = false;
+                                else if ( ! des->designators.empty() ) {
+                                        if ( (des->designators.size() == 1) ) {
+                                                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);
+                                                        for ( auto candidate : candidates ) {
+                                                                if ( dynamic_cast<const ast::EnumInstType *>(candidate.id->get_type()) ) {
+                                                                        result = true;
+                                                                        break;
+                                                                }
+                                                        }
+                                                } 
+                                        } 
+                                        visit_children = false;
+                                }
+                        }
+                };
         } // anonymous namespace
         /// Check if this expression is or includes a deleted expression
@@ -1507 +1538 @@
                                 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" );
+                                                ast::Pass<ResolveDesignators_new> res( context );
+                                                maybe_accept( mutDecl->init.get(), res );
+                                                if ( !res.core.result ) {
+                                                        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