Changeset b5b0907 for src/Tests/Attributes.c

Timestamp:

Jun 15, 2015, 12:45:26 PM (11 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

94b4364

Parents:

ea9b9d3 (diff), a1d5d2a (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' into resolver

Conflicts:

src/CodeGen/CodeGenerator.cc

File:

• src/Tests/Attributes.c (modified) (1 diff)

src/Tests/Attributes.c

@@ +1 @@
+// I Compile-time resolution
+// =========================
+// 
+// 1. an isolated name, where the argument is implicitly determined by the result context
+// 
+//    @max
+// 
+// 2. a direct application to a manifest type
+// 
+//    @max( int )
+// 
+// 3. constraining a type variable; the application is implicitly performed at the call site as in (2)
+// 
+//    forall( type T | { T @max( T ); } ) T x( T t );
+// 
+// 
+// II Run-time resolution
+// ======================
+// 
+// 1. an indirect reference, where the argument is implicitly determined by the result context
+// 
+//    attr_var = &@max;
+//    x = (*attr_var);
+// 
+// 2. an indirect application to a manifest type
+// 
+//    (*attr_var)( int )
+// 
+// 3. a direct application to a type variable
+// 
+//    @max( T )
+// 
+// Under what circumstances can this be done at compile/link time?
+// 
+// 
+// III Declaration forms
+// =====================
+// 
+// 1. monomorphic with implicit argument
+// 
+//    int @max;
+// 
+// 2. monomorphic with explicit argument
+// 
+//    int @max( int );
+// 
+// 3. polymorphic
+// 
+//    forall( type T | constraint( T ) ) int @attr( T );
+
 int @max = 3;
 
 int main() {
     int x;
-    type @type(type t);         // compiler intrinsic
+    type @type(type t);                                                                 // compiler intrinsic
     type @widest(type t);
-    @type(x) *y;                // gcc: typeof(x) *y;
-    const @widest(double) *w;   // gcc: const typeof(x) *w;
-    * @type(3 + 4) z;           // cfa declaration syntax
+    @type(x) *y;                                                                                // gcc: typeof(x) *y;
+    const @widest(double) *w;                                                   // gcc: const typeof(x) *w;
+    * @type(3 + 4) z;                                                                   // cfa declaration syntax
     y = @max;           
     z = @max(x) + @size(int);