Allow declaring vector type with arbitrary symbol for size so long as…

… it ends up as an IntLiteral.

src/neat/stuff.nt

@@ -309,14 +309,11 @@ with (parser.transaction)
             auto element = lexicalContext.compiler.parseType(parser, lexicalContext)??
                 else return parser.fail("element type expected");
             parser.expectToken(TokenType.comma)?;
-            auto count = lexicalContext.compiler.parseExpression(parser, lexicalContext)?;
-            parser.assert_(count && count.instanceOf(ASTNumberLiteral), "number expected")?;
+            auto count = lexicalContext.compiler.parseExpression(parser, lexicalContext)?
+                .(that? else return parser.fail("number expected"));
             parser.expectToken(TokenType.rparen)?;
             commit;
-            return new ASTVectorType(
-                element,
-                cast(int) count.instanceOf(ASTNumberLiteral).value,
-                parser.to(from));
+            return new ASTVectorType(element, count, parser.to(from));
         }
 
         if (parser.acceptIdentifier("typeof"))

src/neat/vectors.nt

@@ -15,12 +15,17 @@ class ASTVectorType : ASTSymbol
 {
     ASTSymbol elementType;
 
-    int count;
+    ASTSymbol count;
 
     this(this.elementType, this.count, this.locRange=__CALLER__) { }
 
     override (Type | Error) compile(Context context)
     {
+        auto count = this.count.compile(context)?
+            .beExpression(this.locRange)?
+            .instanceOf(IntLiteral)
+            .(that? else return locRange.fail("number expected"))
+            .value;
         return new VectorType(
             this.elementType.compile(context)?.beType(this.locRange)?, count);
     }