Changeset 0dd9a5e

Timestamp:

Nov 10, 2020, 3:14:14 AM (4 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

3ff4c1e

Parents:

18f0b70

Message:

delay autogen resolve

Location:

src

Files:

• AST/Pass.impl.hpp (modified) (1 diff)
• AST/Pass.proto.hpp (modified) (1 diff)
• ResolvExpr/ResolveTypeof.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• SymTab/Autogen.cc (modified) (1 diff)

src/AST/Pass.impl.hpp

@@ -423 +423 @@
                 }
                 catch( SemanticErrorException &e ) {
-                        errors.append( e );
+                        if (__pass::onError (visitor.core, *i, 0))
+                                errors.append( e );
                 }
 

src/AST/Pass.proto.hpp

@@ -266 +266 @@
         static void endTrace(core_t &, long) {}
 
+        // Allows visitor to handle an error on top-level declarations, and possibly suppress the error.
+        // If onError() returns false, the error will be ignored. By default, it returns true.
+
+        template< typename core_t >
+        static bool onError (core_t &, ptr<Decl> &, long) { return true; }
+
+        template< typename core_t >
+        static auto onError (core_t & core, ptr<Decl> & decl, int) -> decltype(core.onError(decl)) {
+                return core.onError(decl); 
+        }
+
         // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
         // All passes which have such functions are assumed desire this behaviour

src/ResolvExpr/ResolveTypeof.cc

@@ -165 +165 @@
 }
 
+struct FixArrayDimension {
+        // should not require a mutable symbol table - prevent pass template instantiation
+        const ast::SymbolTable & _symtab; 
+        FixArrayDimension(const ast::SymbolTable & symtab): _symtab(symtab) {}
+
+        const ast::ArrayType * previsit (const ast::ArrayType * arrayType) {
+                if (!arrayType->dimension) return arrayType;
+                auto mutType = mutate(arrayType);
+                ast::ptr<ast::Type> sizetype = ast::sizeType ? ast::sizeType : new ast::BasicType(ast::BasicType::LongUnsignedInt); 
+                mutType->dimension = findSingleExpression(arrayType->dimension, sizetype, _symtab);
+
+                if (InitTweak::isConstExpr(mutType->dimension)) {
+                        mutType->isVarLen = ast::LengthFlag::FixedLen;
+                }
+                else {
+                        mutType->isVarLen = ast::LengthFlag::VariableLen;
+                }
+                return mutType;
+        }
+};
+
+const ast::Type * fixArrayType( const ast::Type * type, const ast::SymbolTable & symtab) {
+        ast::Pass<FixArrayDimension> visitor {symtab};
+        return type->accept(visitor);
+}
+
 const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ast::SymbolTable & symtab ) {
         if (!decl->isTypeFixed) { 
                 auto mutDecl = mutate(decl);
                 auto resolvedType = resolveTypeof(decl->type, symtab);
+                resolvedType = fixArrayType(resolvedType, symtab);
                 mutDecl->type = resolvedType;
 
                 // check variable length if object is an array.
                 // xxx - should this be part of fixObjectType?
+
+                /*
                 if (auto arrayType = dynamic_cast<const ast::ArrayType *>(resolvedType)) {
+                        auto dimExpr = findSingleExpression(arrayType->dimension, ast::sizeType, symtab);
                         if (auto varexpr = arrayType->dimension.as<ast::VariableExpr>()) {// hoisted previously
                                 if (InitTweak::isConstExpr(varexpr->var.strict_as<ast::ObjectDecl>()->init)) {
@@ -182 +212 @@
                         }
                 }
+                */
+
 
                 if (!mutDecl->name.empty()) 

src/ResolvExpr/Resolver.cc

@@ -1289 +1289 @@
                 void beginScope() { managedTypes.beginScope(); }
                 void endScope() { managedTypes.endScope(); }
+                bool onError(ast::ptr<ast::Decl> & decl);
         };
         // size_t Resolver_new::traceId = Stats::Heap::new_stacktrace_id("Resolver");
@@ -2066 +2067 @@
         }
 
+        // suppress error on autogen functions and mark invalid autogen as deleted.
+        bool Resolver_new::onError(ast::ptr<ast::Decl> & decl) {
+                if (auto functionDecl = decl.as<ast::FunctionDecl>()) {
+                        // xxx - can intrinsic gen ever fail?
+                        if (functionDecl->linkage == ast::Linkage::AutoGen) { 
+                                auto mutDecl = mutate(functionDecl);
+                                mutDecl->isDeleted = true;
+                                mutDecl->stmts = nullptr;
+                                decl = mutDecl;
+                                return false;
+                        }
+                }
+                return true;
+        }
+
 } // namespace ResolvExpr
 

src/SymTab/Autogen.cc

@@ -347 +347 @@
         void FuncGenerator::resolve( FunctionDecl * dcl ) {
                 try {
-                        ResolvExpr::resolveDecl( dcl, indexer );
+                        if (!useNewAST) // attempt to delay resolver call
+                                ResolvExpr::resolveDecl( dcl, indexer );
                         if ( functionNesting == 0 ) {
                                 // forward declare if top-level struct, so that