Changeset 0522ebe

Timestamp:

Feb 26, 2024, 3:49:23 AM (2 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

a4da45e

Parents:

c17dc80

Message:

Add EnumPosType? to type system

Location:

src

Files:

• AST/Fwd.hpp (modified) (1 diff)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• AST/Type.hpp (modified) (1 diff)
• AST/Visitor.hpp (modified) (1 diff)
• CodeGen/GenType.cc (modified) (2 diffs)
• Common/CodeLocationTools.cpp (modified) (1 diff)
• Parser/parser.yy (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (1 diff)
• ResolvExpr/ConversionCost.cc (modified) (2 diffs)
• ResolvExpr/ConversionCost.h (modified) (1 diff)
• ResolvExpr/Unify.cc (modified) (1 diff)
• SymTab/Mangler.cc (modified) (2 diffs)
• Validate/Autogen.cpp (modified) (2 diffs)
• Validate/ReplacePseudoFunc.cpp (modified) (10 diffs)

src/AST/Fwd.hpp

@@ -133 +133 @@
 class OneType;
 class GlobalScopeType;
+class EnumPosType;
 
 class Designation;

src/AST/Pass.hpp

@@ -222 +222 @@
         const ast::Type *             visit( const ast::UnionInstType        * ) override final;
         const ast::Type *             visit( const ast::EnumInstType         * ) override final;
+        const ast::Type *             visit( const ast::EnumPosType          * ) override final;
         const ast::Type *             visit( const ast::TraitInstType        * ) override final;
         const ast::Type *             visit( const ast::TypeInstType         * ) override final;

src/AST/Pass.impl.hpp

@@ -1986 +1986 @@
 
 //--------------------------------------------------------------------------
+// EnumPosType
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::EnumPosType * node ) {
+        VISIT_START( node );
+
+        VISIT_END( Type, node );
+}
+
+//--------------------------------------------------------------------------
 // TraitInstType
 template< typename core_t >

src/AST/Print.cpp

@@ -1576 +1576 @@
         }
 
+        virtual const ast::Type * visit( const ast::EnumPosType * node ) override final {
+                preprint( node );
+                os << "enum pos with ";
+                (*(node->instance)).accept( *this );
+                return node;
+        }
+
         virtual const ast::Type * visit( const ast::TraitInstType * node ) override final {
                 preprint( node );

src/AST/Type.hpp

@@ -362 +362 @@
 using EnumInstType = SueInstType<EnumDecl>;
 
+class EnumPosType final : public Type {
+public:
+        readonly<EnumInstType> instance;
+        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
+        EnumPosType( const EnumInstType * instance ): instance(instance) {}
+        
+private:
+        EnumPosType * clone() const override { return new EnumPosType{ *this }; }
+        MUTATE_FRIEND
+};
+
 /// An instance of a trait type.
 class TraitInstType final : public BaseInstType {

src/AST/Visitor.hpp

@@ -119 +119 @@
     virtual const ast::Type *             visit( const ast::OneType              * ) = 0;
     virtual const ast::Type *             visit( const ast::GlobalScopeType      * ) = 0;
+    virtual const ast::Type *             visit( const ast::EnumPosType          * ) = 0;
     virtual const ast::Designation *      visit( const ast::Designation          * ) = 0;
     virtual const ast::Init *             visit( const ast::SingleInit           * ) = 0;

src/CodeGen/GenType.cc

@@ -46 +46 @@
         void postvisit( ast::UnionInstType const * type );
         void postvisit( ast::EnumInstType const * type );
+        void postvisit( ast::EnumPosType const * type );
         void postvisit( ast::TypeInstType const * type );
         void postvisit( ast::TupleType const * type );
@@ -239 +240 @@
 }
 
+void GenType::postvisit( ast::EnumPosType const * type ) {
+        postvisit( type->instance );
+}
+
 void GenType::postvisit( ast::TypeInstType const * type ) {
         assertf( !options.genC, "TypeInstType should not reach code generation." );

src/Common/CodeLocationTools.cpp

@@ -188 +188 @@
     macro(UnionInstType, Type) \
     macro(EnumInstType, Type) \
+    macro(EnumPosType, Type) \
     macro(TraitInstType, Type) \
     macro(TypeInstType, Type) \

src/Parser/parser.yy

@@ -3006 +3006 @@
         | assertion_list
                 { $$ = DeclarationNode::newTypeParam( ast::TypeDecl::Dtype, new string( DeclarationNode::anonymous.newName() ) )->addAssertions( $1 ); }
+        | ENUM '(' identifier_or_type_name ')' identifier_or_type_name new_type_class type_initializer_opt assertion_list_opt
+                {       
+                        typedefTable.addToScope( *$3, TYPEDIMname, "type_parameter 4" );
+                        typedefTable.addToScope( *$5, TYPEDIMname, "type_parameter 5" );
+                        $$ = DeclarationNode::newTypeParam( $6, $5 )->addTypeInitializer( $7 )->addAssertions( $8 );
+                }
         ;
 

src/ResolvExpr/CandidateFinder.cpp

@@ -893 +893 @@
                 } 
                 else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
-                        // The Attribute Arrays are not yet generated, need to proxy them
-                        // as attribute function call
-                        const CodeLocation & location = cand->expr->location;
-                        if ( enumInst->base && enumInst->base->base ) {
-                                auto valueName = new ast::NameExpr(location, "valueE");
-                                auto untypedValueCall = new ast::UntypedExpr( 
-                                        location, valueName, { aggrExpr } );
-                                auto result = ResolvExpr::findVoidExpression( untypedValueCall, context );
-                                assert( result.get() );
-                                CandidateRef newCand = std::make_shared<Candidate>(
-                                        *cand, result, Cost::safe );
-                                candidates.emplace_back( std::move( newCand ) );
-                        }
+                        if (enumInst->base && enumInst->base->base) {
+            const CodeLocation &location = cand->expr->location;
+
+            CandidateFinder funcFinder(context, tenv);
+            auto nameExpr = new ast::NameExpr(location, "valueE");
+            ResolveMode mode = {true, false, selfFinder.candidates.empty()};
+            funcFinder.find( nameExpr, mode );
+
+            // make variableExpr itself the candidate for the value Call
+            ExplodedArgs argExpansions;
+            argExpansions.emplace_back();
+            auto &argE = argExpansions.back();
+
+            argE.emplace_back(*cand, symtab); // Use the typed name expr as param for value
+
+            CandidateList found;
+            SemanticErrorException errors;
+
+            for (CandidateRef &func : funcFinder) {
+                try {
+                    const ast::Type *funcResult =
+                        func->expr->result->stripReferences();
+                    if (auto pointer = dynamic_cast<const ast::PointerType *>(
+                            funcResult)) {
+                        if (auto function =
+                                pointer->base.as<ast::FunctionType>()) {
+                            CandidateRef newFunc{new Candidate{*func}};
+                            newFunc->expr = referenceToRvalueConversion(
+                                newFunc->expr, newFunc->cost);
+                            makeFunctionCandidates( location,
+                                                   newFunc, function,
+                                                   argExpansions, found );
+                        }
+                    }
+                } catch (SemanticErrorException &e) {
+                    std::cerr
+                        << "Resolving value function should cause an error"
+                        << std::endl;
+                    errors.append(e);
+                }
+            }
+
+            if (found.empty()) {
+                std::cerr << "Resolve value function should always success"
+                          << std::endl;
+            }
+
+            for (CandidateRef &withFunc : found) {
+                withFunc->cost.incSafe();
+                Cost cvtCost =
+                    computeApplicationConversionCost(withFunc, symtab);
+                assert(cvtCost != Cost::infinity);
+
+                candidates.emplace_back(std::move(withFunc));
+            }
+        }
                 }
         }
@@ -1401 +1444 @@
         }
 
-        void Finder::postvisit( const ast::VariableExpr * variableExpr ) {
-                // not sufficient to just pass `variableExpr` here, type might have changed since
-                addCandidate( variableExpr, tenv );             
-        }
+    void Finder::postvisit(const ast::VariableExpr *variableExpr) {
+        // not sufficient to just pass `variableExpr` here, type might have changed
+
+        auto cand = new Candidate(variableExpr, tenv);
+        candidates.emplace_back(cand);
+
+        if (auto enumInst = dynamic_cast<const ast::EnumInstType *>(
+                variableExpr->var->get_type())) {
+            if (enumInst->base && enumInst->base->base) {
+                const CodeLocation &location = cand->expr->location;
+
+                CandidateFinder funcFinder(context, tenv);
+                auto nameExpr = new ast::NameExpr(location, "valueE");
+                ResolveMode mode = {true, false, selfFinder.candidates.empty()};
+                funcFinder.find( nameExpr, mode );
+
+                // make variableExpr itself the candidate for the value Call
+                ExplodedArgs argExpansions;
+                argExpansions.emplace_back();
+                auto &argE = argExpansions.back();
+
+                argE.emplace_back(*cand, symtab);
+
+                CandidateList found;
+                SemanticErrorException errors;
+
+                for (CandidateRef &func : funcFinder) {
+                    try {
+                    const ast::Type *funcResult =
+                        func->expr->result->stripReferences();
+                    if (auto pointer = dynamic_cast<const ast::PointerType *>(
+                            funcResult)) {
+                        if (auto function =
+                                pointer->base.as<ast::FunctionType>()) {
+                            CandidateRef newFunc{new Candidate{*func}};
+                            newFunc->expr = referenceToRvalueConversion(
+                                newFunc->expr, newFunc->cost);
+                            makeFunctionCandidates(variableExpr->location,
+                                                   newFunc, function,
+                                                   argExpansions, found);
+                        }
+                    }
+                    } catch (SemanticErrorException &e) {
+                        std::cerr
+                            << "Resolving value function should cause an error"
+                            << std::endl;
+                        errors.append(e);
+                    }
+                }
+
+                if (found.empty()) {
+                    std::cerr << "Resolve value function should always success"
+                            << std::endl;
+                }
+
+                for (CandidateRef &withFunc : found) {
+                    withFunc->cost.incSafe();
+                    Cost cvtCost =
+                        computeApplicationConversionCost(withFunc, symtab);
+                    assert(cvtCost != Cost::infinity);
+
+                    candidates.emplace_back(std::move(withFunc));
+                }
+            }
+        }
+    }
 
         void Finder::postvisit( const ast::ConstantExpr * constantExpr ) {

src/ResolvExpr/CommonType.cc

@@ -397 +397 @@
                                         result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
                                 }
+                        }
+                } else if ( const ast::EnumPosType * pos = dynamic_cast< const ast::EnumPosType * >( type2 ) ) {
+                        ast::BasicType::Kind kind = commonTypes[ basic->kind ][ ast::BasicType::SignedInt ];
+                        if (
+                                ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
+                                        || widen.first )
+                                && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
+                                        || widen.second )
+                        ) {
+                                result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
                         }
                 }

src/ResolvExpr/ConversionCost.cc

@@ -278 +278 @@
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
-        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+        } 
+        else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 auto enumDecl = enumInst->base;
-                if ( auto baseType = enumDecl->base.get() ) {
-                        cost = costCalc( basicType, baseType, srcIsLvalue, symtab, env );
-                        cost.incUnsafe();
+                if ( enumDecl->base.get() ) {
+                        // cost = costCalc( basicType, baseType, srcIsLvalue, symtab, env );
+                        // cost.incUnsafe();
+                        cost = Cost::infinity;
                 } else {
             cost = Cost::unsafe;
@@ -365 +367 @@
         cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
         // }
+        if ( cost < Cost::unsafe ) {
+                cost.incSafe();
+        }
+}
+
+void ConversionCost::postvisit( const ast::EnumPosType * ) {
+        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();

src/ResolvExpr/ConversionCost.h

@@ -72 +72 @@
         void postvisit( const ast::ZeroType * zeroType );
         void postvisit( const ast::OneType * oneType );
+        void postvisit( const ast::EnumPosType * posType );
 private:
         // refactor for code resue

src/ResolvExpr/Unify.cc

@@ -517 +517 @@
                 }
 
+                void postvisit( const ast::EnumPosType * posType ) {
+                        // Does nothing for now. Handled in ReplacePseudoFunc
+                        // Might move here in the future
+                }
+
                 void postvisit( const ast::TraitInstType * aggrType ) {
                         handleRefType( aggrType, type2 );

src/SymTab/Mangler.cc

@@ -59 +59 @@
         void postvisit( const ast::QualifiedType * qualType );
 
+        void postvisit( const ast::EnumPosType * posType );
+
         /// The result is the current constructed mangled name.
         std::string result() const { return mangleName; }
@@ -277 +279 @@
         assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
         mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
+}
+
+void Mangler::postvisit( const ast::EnumPosType * pos ) {
+        postvisit( pos->instance );
+        mangleName += "_pos";
 }
 

src/Validate/Autogen.cpp

@@ -206 +206 @@
         ast::FunctionDecl * genLabelProto() const;
         ast::FunctionDecl * genValueProto() const;
+        // ast::FunctionDecl * genValueProto2() const;
 };
 
@@ -790 +791 @@
 }
 
+// ast::FunctionDecl * EnumFuncGenerator::genValueProto2() const {
+//      return genProto( "valueE", 
+//              { new ast::ObjectDecl( getLocation(), "_i", new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
+//              { new ast::ObjectDecl( getLocation(), "_ret", ast::deepCopy( decl->base ) ) } );
+// }
+
 void EnumFuncGenerator::genAttrFuncForward() {  
         if ( decl->base ) {
                 ast::FunctionDecl *(EnumFuncGenerator::*attrProtos[3])() const = {
                         &EnumFuncGenerator::genPosProto, &EnumFuncGenerator::genLabelProto, 
-                        &EnumFuncGenerator::genValueProto };
+                        &EnumFuncGenerator::genValueProto
+                        // , &EnumFuncGenerator::genValueProto2 
+                        };
                 for ( auto & generator : attrProtos ) {
                         produceForwardDecl( (this->*generator)() );

src/Validate/ReplacePseudoFunc.cpp

@@ -6 +6 @@
 #include "AST/Inspect.hpp"
 #include "AST/Pass.hpp"
+#include "AST/Print.hpp"
 #include "AST/Stmt.hpp"
 #include "Common/utility.h"
+#include "ResolvExpr/CandidateFinder.hpp"
 #include "ResolvExpr/Resolver.h"
 #include "SymTab/Mangler.h"
 
-#include "AST/Print.hpp"
-
-#include "ResolvExpr/CandidateFinder.hpp"
-
 namespace Validate {
 
@@ -21 +19 @@
 std::set<std::string> queryLabels;
 std::set<std::string> queryValues;
+
+struct ReplaceEnumInstWithPos final : public ast::WithShortCircuiting {
+    void previsit(const ast::ObjectDecl*) { visit_children = false; }
+    const ast::ObjectDecl* postvisit(const ast::ObjectDecl* decl) {
+        auto enumInst = decl->type.strict_as<ast::EnumInstType>();
+        auto enumPos = new ast::EnumPosType(enumInst);
+        auto ret = ast::mutate_field(decl, &ast::ObjectDecl::type, enumPos);
+        ret = ast::mutate_field(ret, &ast::ObjectDecl::mangleName,
+                                Mangle::mangle(ret));
+        return ret;
+    }
+};
+
+const inline std::string getValueArrayName(std::string enumName) {
+    return "values_" + enumName;
+}
 
 // struct AutoInit {
@@ -32 +46 @@
     void previsit(const ast::ApplicationExpr* expr);
     void previsit(const ast::CastExpr* expr);
-    void previsit(const ast::VariableExpr* ) { visit_children = false; }
+    void previsit(const ast::VariableExpr*) { visit_children = false; }
 
     ast::Expr const* postvisit(const ast::VariableExpr* expr);
@@ -66 +80 @@
     auto varExpr = expr->func.as<ast::VariableExpr>();
     auto fname = ast::getFunctionName(expr);
-        if ( !varExpr || varExpr->var->linkage == ast::Linkage::Intrinsic ) {
-        if ( fname == "?{}" || fname == "?=?" )
-                    visit_children = false;
-        }
+    if (!varExpr || varExpr->var->linkage == ast::Linkage::Intrinsic) {
+        if (fname == "?{}" || fname == "?=?") visit_children = false;
+    }
 
     if (fname == "labelE" || fname == "valueE" || fname == "posE") {
@@ -94 +107 @@
             auto untyped = new ast::UntypedExpr(
                 expr->location, new ast::NameExpr(expr->location, "valueE"),
-                { std::move( expr ) });
+                {std::move(expr)});
             ResolvExpr::ResolveContext context{symtab, transUnit().global};
             auto result = ResolvExpr::findVoidExpression(untyped, context);
             ast::ptr<ast::ApplicationExpr> ret =
-                    result.strict_as<ast::ApplicationExpr>();
-            return ast::deepCopy( ret );
+                result.strict_as<ast::ApplicationExpr>();
+            return ast::deepCopy(ret);
         }
     }
@@ -132 +145 @@
 }
 
-const ast::Init * getAutoInit( const CodeLocation & location,
-    const ast::Type * type, ResolvExpr::ResolveContext context, const ast::Init * prev ) {
-    if ( auto prevInit = dynamic_cast< const ast::SingleInit * >( prev ) ) {
+const ast::Init* getAutoInit(const CodeLocation& location,
+                             const ast::Type* type,
+                             ResolvExpr::ResolveContext context,
+                             const ast::Init* prev) {
+    if (auto prevInit = dynamic_cast<const ast::SingleInit*>(prev)) {
         auto prevInitExpr = prevInit->value;
-        if ( auto constInit = prevInitExpr.as< ast::ConstantExpr >() ) {
+        if (auto constInit = prevInitExpr.as<ast::ConstantExpr>()) {
             // Assume no string literal for now
             return new ast::SingleInit(
-                location,
-                ast::ConstantExpr::from_int(
-                    location, constInit->intValue() + 1 )
-            );
+                location, ast::ConstantExpr::from_int(
+                              location, constInit->intValue() + 1));
         } else {
             auto untypedThisInit = new ast::UntypedExpr(
-                    location,
-                    new ast::NameExpr( location, "?++" ),
-                    { prevInitExpr }
-                );
-            auto typedInit = ResolvExpr::findSingleExpression(untypedThisInit, type,
-                context );
-            return new ast::SingleInit( location, typedInit );
-        }
-    }
-    SemanticError( prev, "Auto Init a List is not implemented" );
+                location, new ast::NameExpr(location, "?++"), {prevInitExpr});
+            auto typedInit = ResolvExpr::findSingleExpression(untypedThisInit,
+                                                              type, context);
+            return new ast::SingleInit(location, typedInit);
+        }
+    }
+    SemanticError(prev, "Auto Init a List is not implemented");
     return prev;
 }
@@ -167 +177 @@
     auto type = enumDecl->base;
 
-    for ( size_t i = 0; i < enumDecl->members.size(); i++ ) {
-        ast::ptr<ast::Decl> mem = enumDecl->members.at( i );
-        auto memAsObjectDecl = mem.as< ast::ObjectDecl >();
-        assert( memAsObjectDecl );
-        if ( memAsObjectDecl->init ) {
-            inits.emplace_back( memAsObjectDecl->init );
+    for (size_t i = 0; i < enumDecl->members.size(); i++) {
+        ast::ptr<ast::Decl> mem = enumDecl->members.at(i);
+        auto memAsObjectDecl = mem.as<ast::ObjectDecl>();
+        assert(memAsObjectDecl);
+        if (memAsObjectDecl->init) {
+            inits.emplace_back(memAsObjectDecl->init);
         } else {
-            const CodeLocation & location = mem->location;
-            if ( i == 0 ) {
-                inits.emplace_back( new ast::SingleInit( 
-                    location, 
-                    ast::ConstantExpr::from_int( mem->location, 0 )
-                ) );
+            const CodeLocation& location = mem->location;
+            if (i == 0) {
+                inits.emplace_back(new ast::SingleInit(
+                    location, ast::ConstantExpr::from_int(mem->location, 0)));
             } else {
-                inits.emplace_back( getAutoInit( location, enumDecl->base, 
-                    ResolvExpr::ResolveContext{symtab, transUnit().global}, 
-                    inits.at( i - 1 ).as<ast::SingleInit>()) );
+                inits.emplace_back(getAutoInit(
+                    location, enumDecl->base,
+                    ResolvExpr::ResolveContext{symtab, transUnit().global},
+                    inits.at(i - 1).as<ast::SingleInit>()));
             }
         }
         labels.emplace_back(new ast::SingleInit(
-        location, ast::ConstantExpr::from_string(location, mem->name)));
-    } 
+            location, ast::ConstantExpr::from_string(location, mem->name)));
+    }
     if (queryValues.count(enumDecl->name)) {
         auto init = new ast::ListInit(location, std::move(inits));
@@ -219 +228 @@
 ast::ApplicationExpr const* getPseudoFuncApplication(
     const CodeLocation location, ResolvExpr::ResolveContext context,
-    const ast::VariableExpr* arg, const ast::EnumDecl* base, const std::string & name) {
+    const ast::VariableExpr* arg, const ast::EnumDecl* base,
+    const std::string& name) {
     ast::Expr* toResolve = new ast::NameExpr(location, name + base->name);
-    auto result = ResolvExpr::findVoidExpression(toResolve, context);
-    assert(result.get());
-    auto arrAsVar = result.strict_as<ast::VariableExpr>();
-    auto untyped = new ast::UntypedExpr(
-        location, new ast::NameExpr(location, "?[?]"),
-        { std::move(arrAsVar), std::move(arg) });
-    auto typedResult = ResolvExpr::findVoidExpression(untyped, context);
-
-    ast::ptr<ast::ApplicationExpr> ret =
-        typedResult.strict_as<ast::ApplicationExpr>();
-    return ast::deepCopy(ret);
+    // Find the request arrary
+    auto arr = ResolvExpr::findVoidExpression(toResolve, context);
+    assert(arr.get());
+    auto arrAsVar = arr.strict_as<ast::VariableExpr>();
+    // change EnumInstType to EnumPosType to avoid recursive resolution
+    auto argAsDecl = arg->var.as<ast::ObjectDecl>();
+    if (argAsDecl->type.as<ast::EnumInstType>()) {
+        ast::Pass<ReplaceEnumInstWithPos> replacer;
+        auto rep = argAsDecl->accept(replacer);
+        auto mutatedArg = ast::mutate_field(arg, &ast::VariableExpr::var, rep);
+        auto untyped =
+            new ast::UntypedExpr(location, new ast::NameExpr(location, "?[?]"),
+                                 {std::move(arrAsVar), mutatedArg});
+        auto typedResult = ResolvExpr::findVoidExpression(untyped, context);
+        ast::ptr<ast::ApplicationExpr> ret =
+            typedResult.strict_as<ast::ApplicationExpr>();
+        return ast::deepCopy(ret);
+    } else {
+        auto untyped =
+            new ast::UntypedExpr(location, new ast::NameExpr(location, "?[?]"),
+                                 {std::move(arrAsVar), arg});
+        auto typedResult = ResolvExpr::findVoidExpression(untyped, context);
+
+        ast::ptr<ast::ApplicationExpr> ret =
+            typedResult.strict_as<ast::ApplicationExpr>();
+        return ast::deepCopy(ret);
+    }
 }
 
@@ -250 +276 @@
         const ast::ObjectDecl* argAsVar = arg->var.as<const ast::ObjectDecl>();
         const std::string referredName = argAsVar->name;
-        const ast::EnumInstType* argType =
-            argAsVar->type.as<const ast::EnumInstType>();
-        if (!argType) {
+
+        if (const ast::EnumInstType* argTypeAsEnumInst =
+                argAsVar->type.as<const ast::EnumInstType>()) {
+            const ast::EnumDecl* base = argTypeAsEnumInst->base;
+            ResolvExpr::ResolveContext context{symtab, transUnit().global};
+            // If resolvable as constant
+            for (size_t i = 0; i < base->members.size(); i++) {
+                if (base->members[i]->name == referredName) {
+                    if (fname == "posE")
+                        return ast::ConstantExpr::from_int(expr->location, i);
+                    else if (fname == "labelE")
+                        return ast::ConstantExpr::from_string(expr->location,
+                                                              referredName);
+                    else {
+                        return getPseudoFuncApplication(
+                            location, context, arg.get(), base, "values_");
+                    }
+                }
+            }
+
+            if (fname == "labelE") {
+                if (auto labelExpr = getPseudoFuncApplication(
+                        location, context, arg.get(), base, "labels_")) {
+                    return labelExpr;
+                }
+            } else if (fname == "valueE") {
+                if (auto valueExpr = getPseudoFuncApplication(
+                        location, context, arg.get(), base, "values_")) {
+                    return valueExpr;
+                }
+            } else {  // it is position; replace itself
+                return std::move(arg.get());
+            }
+        } else if (const ast::EnumPosType* argTypeAsPos =
+                       argAsVar->type.as<const ast::EnumPosType>()) {
+            const ast::EnumDecl* base = argTypeAsPos->instance->base;
+            ResolvExpr::ResolveContext context{symtab, transUnit().global};
+            if (fname == "labelE") {
+                if (auto labelExpr = getPseudoFuncApplication(
+                        location, context, arg.get(), base, "labels_")) {
+                    return labelExpr;
+                }
+            } else if (fname == "valueE") {
+                if (auto valueExpr = getPseudoFuncApplication(
+                        location, context, arg.get(), base, "values_")) {
+                    return valueExpr;
+                }
+            } else {  // it is position; replace itself
+                return std::move(arg.get());
+            }
+        } else {
             SemanticError(argAsVar,
                           "Pseudo Enum Expression can only be used on an "
                           "enumeration instance");
         }
-        const ast::EnumDecl* base = argType->base;
-        ResolvExpr::ResolveContext context{symtab, transUnit().global};
-        // If resolvable as constant
-        for (size_t i = 0; i < base->members.size(); i++) {
-            if (base->members[i]->name == referredName) {
-                if (fname == "posE")
-                    return ast::ConstantExpr::from_int(expr->location, i);
-                else if (fname == "labelE")
-                    return ast::ConstantExpr::from_string(expr->location,
-                                                          referredName);
-                else {
-                    return getPseudoFuncApplication(location, context, arg.get(),
-                                               base, "values_");                    
-                }
-
-            }
-        }
-
-        if (fname == "labelE") {
-            if (auto labelExpr =
-                    getPseudoFuncApplication(location, context, arg.get(), base, "labels_")) {
-                return labelExpr;
-            }
-        } else if (fname == "valueE") {
-            if (auto valueExpr =
-                    getPseudoFuncApplication(location, context, arg.get(), base, "values_")) {
-                return valueExpr;
-            }
-        } else { // it is position; replace itself
-            return std::move( arg.get() );
-        }
     }
     return expr;
 }
+
+ast::ptr<ast::Expr> reduceCastExpr(ast::ptr<ast::Expr> expr) {
+    if (auto castExpr = expr.as<ast::CastExpr>()) {
+        return reduceCastExpr(castExpr->arg);
+    }
+    return expr;
+}
+
+struct ReplaceEnumInst final {
+    const ast::Expr* postvisit(const ast::ApplicationExpr* expr) {
+        auto fname = ast::getFunctionName(expr);
+        if (fname != "?[?]") return expr;
+        if (expr->args.size() != 2) return expr;
+
+        auto arg1AsVar =
+            reduceCastExpr(expr->args.front()).as<ast::VariableExpr>();
+        auto arg2AsVar =
+            reduceCastExpr(expr->args.back()).as<ast::VariableExpr>();
+
+        if (!arg1AsVar || !arg2AsVar) return expr;
+
+        auto arg1Asecl = arg1AsVar->var.as<ast::ObjectDecl>();
+        auto arg2Asecl = arg2AsVar->var.as<ast::ObjectDecl>();
+
+        if (!arg1Asecl || !arg2Asecl) return expr;
+        auto arrInst = arg1Asecl->type.as<ast::ArrayType>();
+        auto pointerInst = arg1Asecl->type.as<ast::PointerType>();
+        if (!arrInst && !pointerInst) {
+            return expr;
+        }
+        auto enumInst = arg2Asecl->type.as<ast::EnumInstType>();
+        if (!enumInst) return expr;
+
+        const std::string arrName = arg1Asecl->name;
+        if (arrName != getValueArrayName(enumInst->base->name)) return expr;
+        ast::Pass<ReplaceEnumInstWithPos> replacer;
+        auto rep = arg2Asecl->accept(replacer);
+        if (!rep) return expr;
+        auto mutObj =
+            ast::mutate_field(arg2AsVar, &ast::VariableExpr::var, rep);
+        auto mut = ast::mutate_field_index(expr, &ast::ApplicationExpr::args, 1,
+                                           mutObj);
+        return mut;
+    }
+};
 
 }  // namespace
@@ -299 +387 @@
     ast::Pass<PseudoFuncGenerateRoutine>::run(translationUnit);
     ast::Pass<ReplacePseudoFuncCore>::run(translationUnit);
+    ast::Pass<ReplaceEnumInst>::run(translationUnit);
 }
 }  // namespace Validate