Changeset fd54fef for tests/forall.cfa

Timestamp:

Jan 19, 2021, 8:44:29 PM (4 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

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

Children:

dafbde8

Parents:

2f47ea4

Message:

Converting the project to use the new syntax for otype, dtype and ttytpe.

Changed prelude (gen), libcfa and test suite to use it. Added a simple deprecation rule of the old syntax to the parser; we might wish to support both syntaxes "officially," like with an extra CLI switch, but this measure should serve as a simple reminder for our team to try the new syntax.

File:

• tests/forall.cfa (modified) (11 diffs)

tests/forall.cfa

@@ -15 +15 @@
 
 void g1() {
-        forall( otype T ) T f( T ) {};
+        forall( T ) T f( T ) {};
         void f( int ) {};
         void h( void (*p)(void) ) {};
@@ -32 +32 @@
 
 void g2() {
-        forall( otype T ) void f( T, T ) {}
-        forall( otype T, otype U ) void f( T, U ) {}
+        forall( T ) void f( T, T ) {}
+        forall( T, U ) void f( T, U ) {}
 
         int x;
@@ -45 +45 @@
 }
 
-typedef forall ( otype T ) int (* f)( int );
-
-forall( otype T )
+typedef forall ( T ) int (* f)( int );
+
+forall( T )
 void swap( T left, T right ) {
         T temp = left;
@@ -54 +54 @@
 }
 
-trait sumable( otype T ) {
+trait sumable( T ) {
         void ?{}( T &, zero_t );                                                        // 0 literal constructor
         T ?+?( T, T );                                                                          // assortment of additions
@@ -62 +62 @@
 }; // sumable
 
-forall( otype T | sumable( T ) )                                                // use trait
+forall( T | sumable( T ) )                                              // use trait
 T sum( size_t size, T a[] ) {
         T total = 0;                                                                            // initialize by 0 constructor
@@ -70 +70 @@
 } // sum
 
-forall( otype T | { T ?+?( T, T ); T ?++( T & ); [T] ?+=?( T &,T ); } )
+forall( T | { T ?+?( T, T ); T ?++( T & ); [T] ?+=?( T &,T ); } )
 T twice( T t ) {
         return t + t;
 }
 
-forall( otype T | { int ?<?(T, T); } )
+forall( T | { int ?<?(T, T); } )
 T min( T t1, T t2 ) {
         return t1 < t2 ? t1 : t2;
@@ -91 +91 @@
 
 // Multiple forall
-forall( otype T ) forall( otype S ) struct { int i; };
-forall( otype T ) struct { int i; } forall( otype S );
-struct { int i; } forall( otype T ) forall( otype S );
-forall( otype W ) struct { int i; } forall( otype T ) forall( otype S );
+forall( T ) forall( S ) struct { int i; };
+forall( T ) struct { int i; } forall( S );
+struct { int i; } forall( T ) forall( S );
+forall( W ) struct { int i; } forall( T ) forall( S );
 
 // Distribution
 struct P { int i; };
-forall( otype T ) struct Q { T i; };
-forall( otype T ) struct { int i; };
+forall( T ) struct Q { T i; };
+forall( T ) struct { int i; };
 struct KK { int i; };
 inline static {
         void RT1() {}
 }
-forall( otype T ) {
+forall( T ) {
         T RT2( T ) {
                 typedef int TD1;
                 struct S1 { T t; };
         }
-        forall( otype X ) {
+        forall( X ) {
                 typedef int TD2;
                 struct S2 {};
@@ -117 +117 @@
         }
         extern "C" {
-                forall( otype W ) {
+                forall( W ) {
                         W RT3( W ) {}
                         struct S3 {};
@@ -123 +123 @@
         }
         void RT4() {
-                forall( otype W ) struct S4 {};
+                forall( W ) struct S4 {};
                 typedef int TD3;
         }
@@ -147 +147 @@
 
 static inline {
-        forall( otype T ) {
+        forall( T ) {
                 int RT6( T p );
         }
-        forall( otype T, otype U ) {
+        forall( T, U ) {
                 int RT7( T, U );
         }
 }
-static forall( otype T ) {
+static forall( T ) {
         int RT8( T );
 }
-forall( otype T ) inline static {
+forall( T ) inline static {
         int RT9( T ) { T t; return 3; }
 }
 
-forall( otype T | { T ?+?( T, T ); } ) {
-        forall( otype S | { T ?+?( T, S ); } ) {
-                forall( otype W ) T bar( T t, S s ) { return t + s; }
-                forall( otype W | { W ?+?( T, W ); } ) W baz( T t, S s, W w ) { return t + s + w; }
+forall( T | { T ?+?( T, T ); } ) {
+        forall( S | { T ?+?( T, S ); } ) {
+                forall( W ) T bar( T t, S s ) { return t + s; }
+                forall( W | { W ?+?( T, W ); } ) W baz( T t, S s, W w ) { return t + s + w; }
                 struct W { T t; } (int,int) ww;
                 struct P pp;
@@ -170 +170 @@
 }
 
-forall( otype T | { T ?+?( T, T ); } ) forall( otype S | { T ?+?( T, S ); } ) 
+forall( T | { T ?+?( T, T ); } ) forall( S | { T ?+?( T, S ); } ) 
 struct XW { T t; };
 XW(int,int) xww;
 
-forall( otype T ) struct S { T t; } (int) x, y, z;
-forall( otype T ) struct { T t; } (int) a, b, c;
-
-forall( otype T ) static forall( otype S ) {
-    forall( otype X ) struct U {
+forall( T ) struct S { T t; } (int) x, y, z;
+forall( T ) struct { T t; } (int) a, b, c;
+
+forall( T ) static forall( S ) {
+    forall( X ) struct U {
                 T x;
     };
 }
 
-forall( otype T ) {
+forall( T ) {
         extern "C" {
                 struct SS { T t; };