Changeset 660665f for src

Timestamp:

Jun 29, 2021, 5:35:19 PM (4 years ago)

Author:

caparsons <caparson@…>

Branches:

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

Children:

dcad80a

Parents:

5a46e09 (diff), d02e547 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Convert.cpp (modified) (1 diff)
• AST/Decl.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (1 diff)
• AST/Pass.impl.hpp (modified) (5 diffs)
• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• Common/PassVisitor.h (modified) (3 diffs)
• Common/PassVisitor.impl.h (modified) (17 diffs)
• InitTweak/InitTweak.cc (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (1 diff)
• Parser/ExpressionNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/TypedefTable.cc (modified) (2 diffs)
• Parser/lex.ll (modified) (3 diffs)
• Parser/parser.yy (modified) (11 diffs)
• SymTab/Indexer.cc (modified) (3 diffs)
• SymTab/Indexer.h (modified) (2 diffs)
• SymTab/Validate.cc (modified) (15 diffs)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/TypeDecl.cc (modified) (1 diff)
• SynTree/TypeExpr.cc (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)

src/AST/Convert.cpp

@@ -2415 +2415 @@
         }
 
+        virtual void visit( const DimensionExpr * old ) override final {
+                // DimensionExpr gets desugared away in Validate.
+                // As long as new-AST passes don't use it, this cheap-cheerful error
+                // detection helps ensure that these occurrences have been compiled
+                // away, as expected.  To move the DimensionExpr boundary downstream
+                // or move the new-AST translation boundary upstream, implement
+                // DimensionExpr in the new AST and implement a conversion.
+                (void) old;
+                assert(false && "DimensionExpr should not be present at new-AST boundary");
+        }
+
         virtual void visit( const AsmExpr * old ) override final {
                 this->node = visitBaseExpr( old,

src/AST/Decl.cpp

@@ -78 +78 @@
 
 const char * TypeDecl::typeString() const {
-        static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized array length type" };
+        static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized length value" };
         static_assert( sizeof(kindNames) / sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );

src/AST/Decl.hpp

@@ -175 +175 @@
 class TypeDecl final : public NamedTypeDecl {
   public:
-        enum Kind { Dtype, DStype, Otype, Ftype, Ttype, ALtype, NUMBER_OF_KINDS };
+        enum Kind { Dtype, DStype, Otype, Ftype, Ttype, Dimension, NUMBER_OF_KINDS };
 
         Kind kind;

src/AST/Pass.impl.hpp

@@ -479 +479 @@
                         guard_symtab guard { *this };
                         // implicit add __func__ identifier as specified in the C manual 6.4.2.2
-                        static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{ 
+                        static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{
                                 CodeLocation{}, "__func__",
                                 new ast::ArrayType{
@@ -522 +522 @@
         VISIT({
                 guard_symtab guard { * this };
-                maybe_accept( node, &StructDecl::params  );
-                maybe_accept( node, &StructDecl::members );
+                maybe_accept( node, &StructDecl::params     );
+                maybe_accept( node, &StructDecl::members    );
+                maybe_accept( node, &StructDecl::attributes );
         })
 
@@ -543 +544 @@
         VISIT({
                 guard_symtab guard { * this };
-                maybe_accept( node, &UnionDecl::params  );
-                maybe_accept( node, &UnionDecl::members );
+                maybe_accept( node, &UnionDecl::params     );
+                maybe_accept( node, &UnionDecl::members    );
+                maybe_accept( node, &UnionDecl::attributes );
         })
 
@@ -562 +564 @@
         VISIT(
                 // unlike structs, traits, and unions, enums inject their members into the global scope
-                maybe_accept( node, &EnumDecl::params  );
-                maybe_accept( node, &EnumDecl::members );
+                maybe_accept( node, &EnumDecl::params     );
+                maybe_accept( node, &EnumDecl::members    );
+                maybe_accept( node, &EnumDecl::attributes );
         )
 
@@ -577 +580 @@
         VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &TraitDecl::params  );
-                maybe_accept( node, &TraitDecl::members );
+                maybe_accept( node, &TraitDecl::params     );
+                maybe_accept( node, &TraitDecl::members    );
+                maybe_accept( node, &TraitDecl::attributes );
         })
 

src/CodeGen/CodeGenerator.cc

@@ -589 +589 @@
                         output << nameExpr->get_name();
                 } // if
+        }
+
+        void CodeGenerator::postvisit( DimensionExpr * dimensionExpr ) {
+                extension( dimensionExpr );
+                output << "/*non-type*/" << dimensionExpr->get_name();
         }
 

src/CodeGen/CodeGenerator.h

@@ -92 +92 @@
                 void postvisit( TupleIndexExpr * tupleExpr );
                 void postvisit( TypeExpr *typeExpr );
+                void postvisit( DimensionExpr *dimensionExpr );
                 void postvisit( AsmExpr * );
                 void postvisit( StmtExpr * );

src/Common/PassVisitor.h

@@ -167 +167 @@
         virtual void visit( TypeExpr * typeExpr ) override final;
         virtual void visit( const TypeExpr * typeExpr ) override final;
+        virtual void visit( DimensionExpr * dimensionExpr ) override final;
+        virtual void visit( const DimensionExpr * dimensionExpr ) override final;
         virtual void visit( AsmExpr * asmExpr ) override final;
         virtual void visit( const AsmExpr * asmExpr ) override final;
@@ -309 +311 @@
         virtual Expression * mutate( CommaExpr * commaExpr ) override final;
         virtual Expression * mutate( TypeExpr * typeExpr ) override final;
+        virtual Expression * mutate( DimensionExpr * dimensionExpr ) override final;
         virtual Expression * mutate( AsmExpr * asmExpr ) override final;
         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override final;
@@ -542 +545 @@
 class WithIndexer {
 protected:
-        WithIndexer() {}
+        WithIndexer( bool trackIdentifiers = true ) : indexer(trackIdentifiers) {}
         ~WithIndexer() {}
 

src/Common/PassVisitor.impl.h

@@ -636 +636 @@
                 maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->members   , *this );
+                maybeAccept_impl( node->attributes, *this );
         }
 
@@ -656 +657 @@
                 maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->members   , *this );
+                maybeAccept_impl( node->attributes, *this );
         }
 
@@ -676 +678 @@
                 maybeMutate_impl( node->parameters, *this );
                 maybeMutate_impl( node->members   , *this );
+                maybeMutate_impl( node->attributes, *this );
         }
 
@@ -697 +700 @@
                 maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->members   , *this );
+                maybeAccept_impl( node->attributes, *this );
         }
 
@@ -714 +718 @@
                 maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->members   , *this );
+                maybeAccept_impl( node->attributes, *this );
         }
 
@@ -732 +737 @@
                 maybeMutate_impl( node->parameters, *this );
                 maybeMutate_impl( node->members   , *this );
+                maybeMutate_impl( node->attributes, *this );
         }
 
@@ -750 +756 @@
         maybeAccept_impl( node->parameters, *this );
         maybeAccept_impl( node->members   , *this );
+        maybeAccept_impl( node->attributes, *this );
 
         VISIT_END( node );
@@ -763 +770 @@
         maybeAccept_impl( node->parameters, *this );
         maybeAccept_impl( node->members   , *this );
+        maybeAccept_impl( node->attributes, *this );
 
         VISIT_END( node );
@@ -776 +784 @@
         maybeMutate_impl( node->parameters, *this );
         maybeMutate_impl( node->members   , *this );
+        maybeMutate_impl( node->attributes, *this );
 
         MUTATE_END( Declaration, node );
@@ -790 +799 @@
                 maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->members   , *this );
+                maybeAccept_impl( node->attributes, *this );
         }
 
@@ -805 +815 @@
                 maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->members   , *this );
+                maybeAccept_impl( node->attributes, *this );
         }
 
@@ -820 +831 @@
                 maybeMutate_impl( node->parameters, *this );
                 maybeMutate_impl( node->members   , *this );
+                maybeMutate_impl( node->attributes, *this );
         }
 
@@ -2507 +2519 @@
 
 //--------------------------------------------------------------------------
+// DimensionExpr
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( DimensionExpr * node ) {
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const DimensionExpr * node ) {
+        VISIT_START( node );
+
+        indexerScopedAccept( node->result, *this );
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Expression * PassVisitor< pass_type >::mutate( DimensionExpr * node ) {
+        MUTATE_START( node );
+
+        indexerScopedMutate( node->env   , *this );
+        indexerScopedMutate( node->result, *this );
+
+        MUTATE_END( Expression, node );
+}
+
+//--------------------------------------------------------------------------
 // AsmExpr
 template< typename pass_type >
@@ -3145 +3187 @@
 
         maybeAccept_impl( node->forall, *this );
-        // xxx - should PointerType visit/mutate dimension?
+        maybeAccept_impl( node->dimension, *this );
         maybeAccept_impl( node->base, *this );
 
@@ -3156 +3198 @@
 
         maybeAccept_impl( node->forall, *this );
-        // xxx - should PointerType visit/mutate dimension?
+        maybeAccept_impl( node->dimension, *this );
         maybeAccept_impl( node->base, *this );
 
@@ -3167 +3209 @@
 
         maybeMutate_impl( node->forall, *this );
-        // xxx - should PointerType visit/mutate dimension?
+        maybeMutate_impl( node->dimension, *this );
         maybeMutate_impl( node->base, *this );
 
@@ -3856 +3898 @@
 
 //--------------------------------------------------------------------------
-// Attribute
+// Constant
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( Constant * node ) {

src/InitTweak/InitTweak.cc

@@ -10 +10 @@
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 23:15:52 2019
-// Update Count     : 8
+// Last Modified On : Wed Jun 16 20:57:22 2021
+// Update Count     : 18
 //
 
@@ -1217 +1217 @@
         void addDataSectonAttribute( ObjectDecl * objDecl ) {
                 objDecl->attributes.push_back(new Attribute("section", {
-                        new ConstantExpr( Constant::from_string(".data#") ),
-                }));
+                        new ConstantExpr( Constant::from_string(".data"
+#if defined( __x86_64 ) || defined( __i386 ) // assembler comment to prevent assembler warning message
+                                        "#"
+#else // defined( __ARM_ARCH )
+                                        "//"
+#endif
+                                ))}));
         }
 
         void addDataSectionAttribute( ast::ObjectDecl * objDecl ) {
                 objDecl->attributes.push_back(new ast::Attribute("section", {
-                        ast::ConstantExpr::from_string(objDecl->location, ".data#"),
-                }));
+                        ast::ConstantExpr::from_string(objDecl->location, ".data"
+#if defined( __x86_64 ) || defined( __i386 ) // assembler comment to prevent assembler warning message
+                                        "#"
+#else // defined( __ARM_ARCH )
+                                        "//"
+#endif
+                                )}));
         }
 

src/Parser/DeclarationNode.cc

@@ -1076 +1076 @@
         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {
                 // otype is internally converted to dtype + otype parameters
-                static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::DStype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype, TypeDecl::Dtype };
+                static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype, TypeDecl::Dimension };
                 static_assert( sizeof(kindMap) / sizeof(kindMap[0]) == TypeDecl::NUMBER_OF_KINDS, "DeclarationNode::build: kindMap is out of sync." );
                 assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
-                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == TypeDecl::Otype || variable.tyClass == TypeDecl::ALtype, variable.initializer ? variable.initializer->buildType() : nullptr );
+                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == TypeDecl::Otype || variable.tyClass == TypeDecl::DStype, variable.initializer ? variable.initializer->buildType() : nullptr );
                 buildList( variable.assertions, ret->get_assertions() );
                 return ret;

src/Parser/ExpressionNode.cc

@@ -509 +509 @@
 } // build_varref
 
+DimensionExpr * build_dimensionref( const string * name ) {
+        DimensionExpr * expr = new DimensionExpr( *name );
+        delete name;
+        return expr;
+} // build_varref
 // TODO: get rid of this and OperKinds and reuse code from OperatorTable
 static const char * OperName[] = {                                              // must harmonize with OperKinds

src/Parser/ParseNode.h

@@ -183 +183 @@
 
 NameExpr * build_varref( const std::string * name );
+DimensionExpr * build_dimensionref( const std::string * name );
 
 Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );

src/Parser/TypedefTable.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 15 20:56:47 2021
-// Update Count     : 260
+// Last Modified On : Wed May 19 08:30:14 2021
+// Update Count     : 262
 //
 
@@ -31 +31 @@
         switch ( kind ) {
           case IDENTIFIER: return "identifier";
+          case TYPEDIMname: return "typedim";
           case TYPEDEFname: return "typedef";
           case TYPEGENname: return "typegen";

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Thu Apr  1 13:22:31 2021
- * Update Count     : 754
+ * Last Modified On : Sun Jun 20 18:41:09 2021
+ * Update Count     : 759
  */
 
@@ -117 +117 @@
 hex_constant {hex_prefix}{hex_digits}{integer_suffix_opt}
 
-                                // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
+                                // GCC: floating D (double), imaginary iI, and decimal floating DF, DD, DL
 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
 floating_size 16|32|32x|64|64x|80|128|128x
 floating_length ([fFdDlLwWqQ]|[fF]{floating_size})
 floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
-floating_suffix_opt ("_"?({floating_suffix}|"DL"))?
+decimal_floating_suffix [dD][fFdDlL]
+floating_suffix_opt ("_"?({floating_suffix}|{decimal_floating_suffix}))?
 decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
 floating_decimal {decimal_digits}"."{exponent}?{floating_suffix_opt}
@@ -234 +235 @@
 continue                { KEYWORD_RETURN(CONTINUE); }
 coroutine               { KEYWORD_RETURN(COROUTINE); }                  // CFA
+_Decimal32              { KEYWORD_RETURN(DECIMAL32); }                  // GCC
+_Decimal64              { KEYWORD_RETURN(DECIMAL64); }                  // GCC
+_Decimal128             { KEYWORD_RETURN(DECIMAL128); }                 // GCC
 default                 { KEYWORD_RETURN(DEFAULT); }
 disable                 { KEYWORD_RETURN(DISABLE); }                    // CFA

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Apr 26 18:41:54 2021
-// Update Count     : 4990
+// Last Modified On : Tue Jun 29 09:12:47 2021
+// Update Count     : 5027
 //
 
@@ -26 +26 @@
 // The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for:
 //
-// 1. designation with '=' (use ':' instead)
-//
-// Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This grammar also has
-// two levels of extensions. The first extensions cover most of the GCC C extensions, except for:
-//
-// 1. designation with and without '=' (use ':' instead)
-
-//
-// All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall
-// (CFA), which fixes several of C's outstanding problems and extends C with many modern language concepts. All of the
-// syntactic extensions for CFA C are marked with the comment "CFA". As noted above, there is one unreconcileable
-// parsing problem between C99 and CFA with respect to designators; this is discussed in detail before the "designation"
-// grammar rule.
+//   designation with '=' (use ':' instead)
+//
+// This incompatibility is discussed in detail before the "designation" grammar rule.  Most of the syntactic extensions
+// from ANSI90 to ANSI11 C are marked with the comment "C99/C11".
+
+// This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions All of the
+// syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall (CFA), which
+// fixes several of C's outstanding problems and extends C with many modern language concepts. All of the syntactic
+// extensions for CFA C are marked with the comment "CFA".
 
 %{
@@ -269 +265 @@
 %token INT128 UINT128 uuFLOAT80 uuFLOAT128                              // GCC
 %token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
+%token DECIMAL32 DECIMAL64 DECIMAL128                                   // GCC
 %token ZERO_T ONE_T                                                                             // CFA
 %token SIZEOF TYPEOF VALIST AUTO_TYPE                                   // GCC
@@ -287 +284 @@
 
 // names and constants: lexer differentiates between identifier and typedef names
-%token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDEFname             TYPEGENname
+%token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDIMname             TYPEDEFname             TYPEGENname
 %token<tok> TIMEOUT                     WOR                                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
 %token<tok> INTEGERconstant     CHARACTERconstant       STRINGliteral
@@ -586 +583 @@
         | quasi_keyword
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+        | TYPEDIMname                                                                           // CFA, generic length argument
+                // { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( DeclarationNode::newFromTypedef( $1 ) ) ) ); }
+                // { $$ = new ExpressionNode( build_varref( $1 ) ); }
+                { $$ = new ExpressionNode( build_dimensionref( $1 ) ); }
         | tuple
         | '(' comma_expression ')'
@@ -630 +631 @@
 postfix_expression:
         primary_expression
-        | postfix_expression '[' assignment_expression ',' comma_expression ']'
-                // { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, new ExpressionNode( build_binary_val( OperKinds::Index, $3, $5 ) ) ) ); }
-                { SemanticError( yylloc, "New array subscript is currently unimplemented." ); $$ = nullptr; }
+        | postfix_expression '[' assignment_expression ',' tuple_expression_list ']'
+                        // Historic, transitional: Disallow commas in subscripts.
+                        // Switching to this behaviour may help check if a C compatibilty case uses comma-exprs in subscripts.
+                // { SemanticError( yylloc, "New array subscript is currently unimplemented." ); $$ = nullptr; }
+                        // Current: Commas in subscripts make tuples.
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
         | postfix_expression '[' assignment_expression ']'
                 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
@@ -1887 +1891 @@
         | uFLOAT128
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat128 ); }
+        | DECIMAL32
+                { SemanticError( yylloc, "_Decimal32 is currently unimplemented." ); $$ = nullptr; }
+        | DECIMAL64
+                { SemanticError( yylloc, "_Decimal64 is currently unimplemented." ); $$ = nullptr; }
+        | DECIMAL128
+                { SemanticError( yylloc, "_Decimal128 is currently unimplemented." ); $$ = nullptr; }
         | COMPLEX                                                                                       // C99
                 { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
@@ -1909 +1919 @@
         // empty
                 { $$ = nullptr; }
-        | vtable;
+        | vtable
         ;
 
@@ -2535 +2545 @@
         | '[' identifier_or_type_name ']'
                 {
-                        typedefTable.addToScope( *$2, TYPEDEFname, "9" );
-                        $$ = DeclarationNode::newTypeParam( TypeDecl::ALtype, $2 );
+                        typedefTable.addToScope( *$2, TYPEDIMname, "9" );
+                        $$ = DeclarationNode::newTypeParam( TypeDecl::Dimension, $2 );
                 }
         // | type_specifier identifier_parameter_declarator
@@ -2550 +2560 @@
         | '*'
                 { $$ = TypeDecl::DStype; }                                              // dtype + sized
+        // | '(' '*' ')'
+        //      { $$ = TypeDecl::Ftype; }
         | ELLIPSIS
                 { $$ = TypeDecl::Ttype; }
@@ -2590 +2602 @@
                 { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
         | assignment_expression
-                { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $1->build()) ); $$ = nullptr; }
         | type_list ',' type
                 { $$ = (ExpressionNode *)($1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) )); }
         | type_list ',' assignment_expression
-                { SemanticError( yylloc, toString("Expression generic parameters are currently unimplemented: ", $3->build()) ); $$ = nullptr; }
-                // { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
+                { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
         ;
 

src/SymTab/Indexer.cc

@@ -74 +74 @@
         }
 
-        Indexer::Indexer()
+        Indexer::Indexer( bool trackIdentifiers )
         : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
-          prevScope(), scope( 0 ), repScope( 0 ) { ++* stats().count; }
+          prevScope(), scope( 0 ), repScope( 0 ), trackIdentifiers( trackIdentifiers ) { ++* stats().count; }
 
         Indexer::~Indexer() {
@@ -110 +110 @@
 
         void Indexer::lookupId( const std::string & id, std::list< IdData > &out ) const {
+                assert( trackIdentifiers );
+
                 ++* stats().lookup_calls;
                 if ( ! idTable ) return;
@@ -434 +436 @@
                         const Declaration * deleteStmt ) {
                 ++* stats().add_calls;
+                if ( ! trackIdentifiers ) return;
                 const std::string &name = decl->name;
                 if ( name == "" ) return;

src/SymTab/Indexer.h

@@ -31 +31 @@
         class Indexer : public std::enable_shared_from_this<SymTab::Indexer> {
         public:
-                explicit Indexer();
+                explicit Indexer( bool trackIdentifiers = true );
                 virtual ~Indexer();
 
@@ -180 +180 @@
                 /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
                 bool hasIncompatibleCDecl( const std::string & id, const std::string & mangleName ) const;
+
+            bool trackIdentifiers;
         };
 } // namespace SymTab

src/SymTab/Validate.cc

@@ -105 +105 @@
 
         struct FixQualifiedTypes final : public WithIndexer {
+                FixQualifiedTypes() : WithIndexer(false) {}
                 Type * postmutate( QualifiedType * );
         };
@@ -174 +175 @@
         };
 
+        /// Does early resolution on the expressions that give enumeration constants their values
+        struct ResolveEnumInitializers final : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveEnumInitializers>, public WithShortCircuiting {
+                ResolveEnumInitializers( const Indexer * indexer );
+                void postvisit( EnumDecl * enumDecl );
+
+          private:
+                const Indexer * local_indexer;
+
+        };
+
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
         struct ForallPointerDecay_old final {
@@ -260 +271 @@
                 void previsit( StructInstType * inst );
                 void previsit( UnionInstType * inst );
+        };
+
+        /// desugar declarations and uses of dimension paramaters like [N],
+        /// from type-system managed values, to tunnneling via ordinary types,
+        /// as char[-] in and sizeof(-) out
+        struct TranslateDimensionGenericParameters : public WithIndexer, public WithGuards {
+                static void translateDimensions( std::list< Declaration * > &translationUnit );
+                TranslateDimensionGenericParameters();
+
+                bool nextVisitedNodeIsChildOfSUIT = false; // SUIT = Struct or Union -Inst Type
+                bool visitingChildOfSUIT = false;
+                void changeState_ChildOfSUIT( bool newVal );
+                void premutate( StructInstType * sit );
+                void premutate( UnionInstType * uit );
+                void premutate( BaseSyntaxNode * node );
+
+                TypeDecl * postmutate( TypeDecl * td );
+                Expression * postmutate( DimensionExpr * de );
+                Expression * postmutate( Expression * e );
         };
 
@@ -307 +337 @@
                 PassVisitor<EnumAndPointerDecay_old> epc;
                 PassVisitor<LinkReferenceToTypes_old> lrt( nullptr );
+                PassVisitor<ResolveEnumInitializers> rei( nullptr );
                 PassVisitor<ForallPointerDecay_old> fpd;
                 PassVisitor<CompoundLiteral> compoundliteral;
@@ -326 +357 @@
                         Stats::Heap::newPass("validate-B");
                         Stats::Time::BlockGuard guard("validate-B");
-                        Stats::Time::TimeBlock("Link Reference To Types", [&]() {
-                                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
-                        });
-                        Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
-                                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
-                        });
-                        Stats::Time::TimeBlock("Hoist Structs", [&]() {
-                                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
-                        });
-                        Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
-                                EliminateTypedef::eliminateTypedef( translationUnit ); //
-                        });
+                        acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                        mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
+                        HoistStruct::hoistStruct( translationUnit );
+                        EliminateTypedef::eliminateTypedef( translationUnit );
                 }
                 {
                         Stats::Heap::newPass("validate-C");
                         Stats::Time::BlockGuard guard("validate-C");
-                        acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes_old
-                        ReturnChecker::checkFunctionReturns( translationUnit );
-                        InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
+                        Stats::Time::TimeBlock("Validate Generic Parameters", [&]() {
+                                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes_old; observed failing when attempted before eliminateTypedef
+                        });
+                        Stats::Time::TimeBlock("Translate Dimensions", [&]() {
+                                TranslateDimensionGenericParameters::translateDimensions( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Resolve Enum Initializers", [&]() {
+                                acceptAll( translationUnit, rei ); // must happen after translateDimensions because rei needs identifier lookup, which needs name mangling
+                        });
+                        Stats::Time::TimeBlock("Check Function Returns", [&]() {
+                                ReturnChecker::checkFunctionReturns( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Fix Return Statements", [&]() {
+                                InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
+                        });
                 }
                 {
@@ -644 +679 @@
         }
 
-        LinkReferenceToTypes_old::LinkReferenceToTypes_old( const Indexer * other_indexer ) {
+        LinkReferenceToTypes_old::LinkReferenceToTypes_old( const Indexer * other_indexer ) : WithIndexer( false ) {
                 if ( other_indexer ) {
                         local_indexer = other_indexer;
@@ -664 +699 @@
         }
 
-        void checkGenericParameters( ReferenceToType * inst ) {
-                for ( Expression * param : inst->parameters ) {
-                        if ( ! dynamic_cast< TypeExpr * >( param ) ) {
-                                SemanticError( inst, "Expression parameters for generic types are currently unsupported: " );
-                        }
-                }
-        }
-
         void LinkReferenceToTypes_old::postvisit( StructInstType * structInst ) {
                 const StructDecl * st = local_indexer->lookupStruct( structInst->name );
@@ -682 +709 @@
                         forwardStructs[ structInst->name ].push_back( structInst );
                 } // if
-                checkGenericParameters( structInst );
         }
 
@@ -695 +721 @@
                         forwardUnions[ unionInst->name ].push_back( unionInst );
                 } // if
-                checkGenericParameters( unionInst );
         }
 
@@ -807 +832 @@
                                 forwardEnums.erase( fwds );
                         } // if
-
-                        for ( Declaration * member : enumDecl->members ) {
-                                ObjectDecl * field = strict_dynamic_cast<ObjectDecl *>( member );
-                                if ( field->init ) {
-                                        // need to resolve enumerator initializers early so that other passes that determine if an expression is constexpr have the appropriate information.
-                                        SingleInit * init = strict_dynamic_cast<SingleInit *>( field->init );
-                                        ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
-                                }
-                        }
                 } // if
         }
@@ -878 +894 @@
                                 typeInst->set_isFtype( typeDecl->kind == TypeDecl::Ftype );
                         } // if
+                } // if
+        }
+
+        ResolveEnumInitializers::ResolveEnumInitializers( const Indexer * other_indexer ) : WithIndexer( true ) {
+                if ( other_indexer ) {
+                        local_indexer = other_indexer;
+                } else {
+                        local_indexer = &indexer;
+                } // if
+        }
+
+        void ResolveEnumInitializers::postvisit( EnumDecl * enumDecl ) {
+                if ( enumDecl->body ) {
+                        for ( Declaration * member : enumDecl->members ) {
+                                ObjectDecl * field = strict_dynamic_cast<ObjectDecl *>( member );
+                                if ( field->init ) {
+                                        // need to resolve enumerator initializers early so that other passes that determine if an expression is constexpr have the appropriate information.
+                                        SingleInit * init = strict_dynamic_cast<SingleInit *>( field->init );
+                                        ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
+                                }
+                        }
                 } // if
         }
@@ -1152 +1189 @@
                 GuardScope( typedeclNames );
                 mutateAll( aggr->parameters, * visitor );
+                mutateAll( aggr->attributes, * visitor );
 
                 // unroll mutateAll for aggr->members so that implicit typedefs for nested types are added to the aggregate body.
@@ -1220 +1258 @@
                         }
                 }
+        }
+
+        // Test for special name on a generic parameter.  Special treatment for the
+        // special name is a bootstrapping hack.  In most cases, the worlds of T's
+        // and of N's don't overlap (normal treamtemt).  The foundations in
+        // array.hfa use tagging for both types and dimensions.  Tagging treats
+        // its subject parameter even more opaquely than T&, which assumes it is
+        // possible to have a pointer/reference to such an object.  Tagging only
+        // seeks to identify the type-system resident at compile time.  Both N's
+        // and T's can make tags.  The tag definition uses the special name, which
+        // is treated as "an N or a T."  This feature is not inteded to be used
+        // outside of the definition and immediate uses of a tag.
+        static inline bool isReservedTysysIdOnlyName( const std::string & name ) {
+                // name's prefix was __CFA_tysys_id_only, before it got wrapped in __..._generic
+                int foundAt = name.find("__CFA_tysys_id_only");
+                if (foundAt == 0) return true;
+                if (foundAt == 2 && name[0] == '_' && name[1] == '_') return true;
+                return false;
         }
 
@@ -1238 +1294 @@
                         TypeSubstitution sub;
                         auto paramIter = params->begin();
-                        for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
-                                if ( i < args.size() ) {
-                                        TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( * std::next( args.begin(), i ) );
-                                        sub.add( (* paramIter)->get_name(), expr->get_type()->clone() );
-                                } else if ( i == args.size() ) {
+                        auto argIter = args.begin();
+                        for ( ; paramIter != params->end(); ++paramIter, ++argIter ) {
+                                if ( argIter != args.end() ) {
+                                        TypeExpr * expr = dynamic_cast< TypeExpr * >( * argIter );
+                                        if ( expr ) {
+                                                sub.add( (* paramIter)->get_name(), expr->get_type()->clone() );
+                                        }
+                                } else {
                                         Type * defaultType = (* paramIter)->get_init();
                                         if ( defaultType ) {
                                                 args.push_back( new TypeExpr( defaultType->clone() ) );
                                                 sub.add( (* paramIter)->get_name(), defaultType->clone() );
+                                                argIter = std::prev(args.end());
+                                        } else {
+                                                SemanticError( inst, "Too few type arguments in generic type " );
                                         }
                                 }
+                                assert( argIter != args.end() );
+                                bool typeParamDeclared = (*paramIter)->kind != TypeDecl::Kind::Dimension;
+                                bool typeArgGiven;
+                                if ( isReservedTysysIdOnlyName( (*paramIter)->name ) ) {
+                                        // coerce a match when declaration is reserved name, which means "either"
+                                        typeArgGiven = typeParamDeclared;
+                                } else {
+                                        typeArgGiven = dynamic_cast< TypeExpr * >( * argIter );
+                                }
+                                if ( ! typeParamDeclared &&   typeArgGiven ) SemanticError( inst, "Type argument given for value parameter: " );
+                                if (   typeParamDeclared && ! typeArgGiven ) SemanticError( inst, "Expression argument given for type parameter: " );
                         }
 
                         sub.apply( inst );
-                        if ( args.size() < params->size() ) SemanticError( inst, "Too few type arguments in generic type " );
                         if ( args.size() > params->size() ) SemanticError( inst, "Too many type arguments in generic type " );
                 }
@@ -1263 +1335 @@
         void ValidateGenericParameters::previsit( UnionInstType * inst ) {
                 validateGeneric( inst );
+        }
+
+        void TranslateDimensionGenericParameters::translateDimensions( std::list< Declaration * > &translationUnit ) {
+                PassVisitor<TranslateDimensionGenericParameters> translator;
+                mutateAll( translationUnit, translator );
+        }
+
+        TranslateDimensionGenericParameters::TranslateDimensionGenericParameters() : WithIndexer( false ) {}
+
+        // Declaration of type variable:           forall( [N] )          ->  forall( N & | sized( N ) )
+        TypeDecl * TranslateDimensionGenericParameters::postmutate( TypeDecl * td ) {
+                if ( td->kind == TypeDecl::Dimension ) {
+                        td->kind = TypeDecl::Dtype;
+                        if ( ! isReservedTysysIdOnlyName( td->name ) ) {
+                                td->sized = true;
+                        }
+                }
+                return td;
+        }
+
+        // Situational awareness:
+        // array( float, [[currentExpr]]     )  has  visitingChildOfSUIT == true
+        // array( float, [[currentExpr]] - 1 )  has  visitingChildOfSUIT == false
+        // size_t x =    [[currentExpr]]        has  visitingChildOfSUIT == false
+        void TranslateDimensionGenericParameters::changeState_ChildOfSUIT( bool newVal ) {
+                GuardValue( nextVisitedNodeIsChildOfSUIT );
+                GuardValue( visitingChildOfSUIT );
+                visitingChildOfSUIT = nextVisitedNodeIsChildOfSUIT;
+                nextVisitedNodeIsChildOfSUIT = newVal;
+        }
+        void TranslateDimensionGenericParameters::premutate( StructInstType * sit ) {
+                (void) sit;
+                changeState_ChildOfSUIT(true);
+        }
+        void TranslateDimensionGenericParameters::premutate( UnionInstType * uit ) {
+                (void) uit;
+                changeState_ChildOfSUIT(true);
+        }
+        void TranslateDimensionGenericParameters::premutate( BaseSyntaxNode * node ) {
+                (void) node;
+                changeState_ChildOfSUIT(false);
+        }
+
+        // Passing values as dimension arguments:  array( float,     7 )  -> array( float, char[             7 ] )
+        // Consuming dimension parameters:         size_t x =    N - 1 ;  -> size_t x =          sizeof(N) - 1   ;
+        // Intertwined reality:                    array( float, N     )  -> array( float,              N        )
+        //                                         array( float, N - 1 )  -> array( float, char[ sizeof(N) - 1 ] )
+        // Intertwined case 1 is not just an optimization.
+        // Avoiding char[sizeof(-)] is necessary to enable the call of f to bind the value of N, in:
+        //   forall([N]) void f( array(float, N) & );
+        //   array(float, 7) a;
+        //   f(a);
+
+        Expression * TranslateDimensionGenericParameters::postmutate( DimensionExpr * de ) {
+                // Expression de is an occurrence of N in LHS of above examples.
+                // Look up the name that de references.
+                // If we are in a struct body, then this reference can be to an entry of the stuct's forall list.
+                // Whether or not we are in a struct body, this reference can be to an entry of a containing function's forall list.
+                // If we are in a struct body, then the stuct's forall declarations are innermost (functions don't occur in structs).
+                // Thus, a potential struct's declaration is highest priority.
+                // A struct's forall declarations are already renamed with _generic_ suffix.  Try that name variant first.
+
+                std::string useName = "__" + de->name + "_generic_";
+                TypeDecl * namedParamDecl = const_cast<TypeDecl *>( strict_dynamic_cast<const TypeDecl *, nullptr >( indexer.lookupType( useName ) ) );
+
+                if ( ! namedParamDecl ) {
+                        useName = de->name;
+                        namedParamDecl = const_cast<TypeDecl *>( strict_dynamic_cast<const TypeDecl *, nullptr >( indexer.lookupType( useName ) ) );
+                }
+
+                // Expect to find it always.  A misspelled name would have been parsed as an identifier.
+                assert( namedParamDecl && "Type-system-managed value name not found in symbol table" );
+
+                delete de;
+
+                TypeInstType * refToDecl = new TypeInstType( 0, useName, namedParamDecl );
+
+                if ( visitingChildOfSUIT ) {
+                        // As in postmutate( Expression * ), topmost expression needs a TypeExpr wrapper
+                        // But avoid ArrayType-Sizeof
+                        return new TypeExpr( refToDecl );
+                } else {
+                        // the N occurrence is being used directly as a runtime value,
+                        // if we are in a type instantiation, then the N is within a bigger value computation
+                        return new SizeofExpr( refToDecl );
+                }
+        }
+
+        Expression * TranslateDimensionGenericParameters::postmutate( Expression * e ) {
+                if ( visitingChildOfSUIT ) {
+                        // e is an expression used as an argument to instantiate a type
+                        if (! dynamic_cast< TypeExpr * >( e ) ) {
+                                // e is a value expression
+                                // but not a DimensionExpr, which has a distinct postmutate
+                                Type * typeExprContent = new ArrayType( 0, new BasicType( 0, BasicType::Char ), e, true, false );
+                                TypeExpr * result = new TypeExpr( typeExprContent );
+                                return result;
+                        }
+                }
+                return e;
         }
 

src/SynTree/Declaration.h

@@ -201 +201 @@
         typedef NamedTypeDecl Parent;
   public:
-        enum Kind { Dtype, DStype, Otype, Ftype, Ttype, ALtype, NUMBER_OF_KINDS };
+        enum Kind { Dtype, DStype, Otype, Ftype, Ttype, Dimension, NUMBER_OF_KINDS };
 
         Kind kind;

src/SynTree/Expression.h

@@ -587 +587 @@
 };
 
+/// DimensionExpr represents a type-system provided value used in an expression ( forrall([N]) ... N + 1 )
+class DimensionExpr : public Expression {
+  public:
+        std::string name;
+
+        DimensionExpr( std::string name );
+        DimensionExpr( const DimensionExpr & other );
+        virtual ~DimensionExpr();
+
+        const std::string & get_name() const { return name; }
+        void set_name( std::string newValue ) { name = newValue; }
+
+        virtual DimensionExpr * clone() const override { return new DimensionExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 /// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
 class AsmExpr : public Expression {

src/SynTree/Mutator.h

@@ -80 +80 @@
         virtual Expression * mutate( CommaExpr * commaExpr ) = 0;
         virtual Expression * mutate( TypeExpr * typeExpr ) = 0;
+        virtual Expression * mutate( DimensionExpr * dimensionExpr ) = 0;
         virtual Expression * mutate( AsmExpr * asmExpr ) = 0;
         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;

src/SynTree/SynTree.h

@@ -85 +85 @@
 class CommaExpr;
 class TypeExpr;
+class DimensionExpr;
 class AsmExpr;
 class ImplicitCopyCtorExpr;

src/SynTree/TypeDecl.cc

@@ -33 +33 @@
 
 const char * TypeDecl::typeString() const {
-        static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized array length type" };
+        static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized length value" };
         static_assert( sizeof(kindNames) / sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );

src/SynTree/TypeExpr.cc

@@ -35 +35 @@
 }
 
+DimensionExpr::DimensionExpr( std::string name ) : Expression(), name(name) {
+        assertf(name != "0", "Zero is not a valid name");
+        assertf(name != "1", "One is not a valid name");
+}
+
+DimensionExpr::DimensionExpr( const DimensionExpr & other ) : Expression( other ), name( other.name ) {
+}
+
+DimensionExpr::~DimensionExpr() {}
+
+void DimensionExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Type-Sys Value: " << get_name();
+        Expression::print( os, indent );
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Visitor.h

@@ -135 +135 @@
         virtual void visit( TypeExpr * node ) { visit( const_cast<const TypeExpr *>(node) ); }
         virtual void visit( const TypeExpr * typeExpr ) = 0;
+        virtual void visit( DimensionExpr * node ) { visit( const_cast<const DimensionExpr *>(node) ); }
+        virtual void visit( const DimensionExpr * typeExpr ) = 0;
         virtual void visit( AsmExpr * node ) { visit( const_cast<const AsmExpr *>(node) ); }
         virtual void visit( const AsmExpr * asmExpr ) = 0;