Changeset 8315947 for src

Timestamp:

Jul 13, 2024, 3:29:22 PM (5 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

2e6b2a0

Parents:

76b507d

Message:

Remove automatic conversion from Enum type name to its len; change With() semantic for enum to avoid type ambiguity (not fully implemented)

Location:

src

Files:

• AST/SymbolTable.cpp (modified) (2 diffs)
• ResolvExpr/Resolver.cpp (modified) (2 diffs)
• Validate/GenericParameter.cpp (modified) (1 diff)

src/AST/SymbolTable.cpp

@@ -419 +419 @@
 void SymbolTable::addWith( const std::vector< ptr<Expr> > & withExprs, const Decl * withStmt ) {
         for ( const Expr * expr : withExprs ) {
-                if ( ! expr->result ) continue;
-                const Type * resTy = expr->result->stripReferences();
-                auto aggrType = dynamic_cast< const BaseInstType * >( resTy );
-                assertf( aggrType, "WithStmt expr has non-aggregate type: %s",
-                        toString( expr->result ).c_str() );
-                const AggregateDecl * aggr = aggrType->aggr();
-                assertf( aggr, "WithStmt has null aggregate from type: %s",
-                        toString( expr->result ).c_str() );
-
-                addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
+                if ( expr->result ) {
+                        const Type * resTy = expr->result->stripReferences();
+                        auto aggrType = dynamic_cast< const BaseInstType * >( resTy );
+                        assertf( aggrType, "WithStmt expr has non-aggregate type: %s",
+                                toString( expr->result ).c_str() );
+                        const AggregateDecl * aggr = aggrType->aggr();
+                        assertf( aggr, "WithStmt has null aggregate from type: %s",
+                                toString( expr->result ).c_str() );
+
+                        addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
+                } else {
+                        auto typeExpr = dynamic_cast< const ast::TypeExpr *>( expr );
+                        if ( !typeExpr ) continue;
+                        auto declEnumInst = typeExpr->type.as<ast::EnumInstType>();
+                        // assertf( declEnumInst,  "WithStmt expr unsupprot type expression: %s",
+                        //      toString( typeExpr->type ).c_str());
+                        if ( !declEnumInst ) continue;
+                        
+                        const EnumDecl * aggr = declEnumInst->aggr();
+                        // assertf( aggr, "WithStmt has null aggregate from type: %s",
+                        //      toString( typeExpr ).c_str() );
+                        // addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
+                        if ( !aggr ) {
+                                aggr = lookupEnum( declEnumInst->name );
+                                assert( aggr );
+                        }
+                        addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
+                }
         }
 }
@@ -800 +818 @@
                 if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
                         if ( ! dynamic_cast<const StructInstType *>(rty)
-                                && ! dynamic_cast<const UnionInstType *>(rty) ) continue;
+                                && ! dynamic_cast<const UnionInstType *>(rty)
+                                && ! dynamic_cast<const EnumInstType *>(rty) ) continue;
                         ResolvExpr::Cost cost = ResolvExpr::Cost::zero;
                         ast::ptr<ast::TypeSubstitution> tmp = expr->env;

src/ResolvExpr/Resolver.cpp

@@ -322 +322 @@
 
 namespace {
-        bool structOrUnion( const Candidate & i ) {
+        bool structOrUnionOrEnum( const Candidate & i ) {
                 const ast::Type * t = i.expr->result->stripReferences();
-                return dynamic_cast< const ast::StructInstType * >( t ) || dynamic_cast< const ast::UnionInstType * >( t );
+                return dynamic_cast< const ast::StructInstType * >( t ) || dynamic_cast< const ast::UnionInstType * >( t ) || dynamic_cast< const ast::EnumInstType * >( t );
         }
         /// Predicate for "Candidate has integral type"
@@ -1140 +1140 @@
         for (auto & expr : exprs) {
                 // only struct- and union-typed expressions are viable candidates
-                expr = findKindExpression( expr, context, structOrUnion, "with expression" );
+                expr = findKindExpression( expr, context, structOrUnionOrEnum, "with expression" );
 
                 // if with expression might be impure, create a temporary so that it is evaluated once

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() );
-        }
+        // 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() );
+        // }
         return expr;
 }