Changeset ac43954 for doc/working

Timestamp:

Aug 3, 2016, 11:30:22 AM (8 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

a14187f

Parents:

ff3fc93

Message:

Add note about what features to add concurrent with the resolver re-write

File:

• doc/working/resolver_design.md (modified) (6 diffs)

doc/working/resolver_design.md

@@ -37 +37 @@
 
 An alternate possibility would be to only count two-arg constructors 
-`void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and  
+`void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and 
 explicit conversions should also have a compiler-enforced restriction to 
 ensure that they are two-arg functions (this restriction may be valuable 
@@ -69 +69 @@
 two chains of conversions, one among the signed integral types, another among 
 the unsigned, and to use monomorphic conversions to allow conversions between 
-signed and unsigned integer types).   
+signed and unsigned integer types).
 
 ### Implementation Details ###
@@ -509 +509 @@
 A variant of the above scheme would be to fix a maximum depth of polymorphic 
 type variables (16 seems like a reasonable choice) at which a parameter would 
-be considered to be effectively monomorphic, and to subtract the value  
+be considered to be effectively monomorphic, and to subtract the value 
 described above from that maximum, clamping the result to a minimum of 0. 
 Under this scheme, assuming a maximum value of 4, `int` has value 0, `T` has 
@@ -577 +577 @@
 specifying the (completely arbitrary) maximum depth as part of the language or 
 allowing the compiler to refuse to accept otherwise well-typed deeply-nested 
-polymorphic types.  
+polymorphic types.
 
 For purposes of determining polymorphism, the list of return types of a 
@@ -951 +951 @@
 `sizeof`, `alignof`, and `offsetof` expressions have at most a single 
 interpretation, of type `size_t`. 
-`sizeof` and `alignof` expressions take either a type or an expression as a  
-an argument; if the argument is a type, it must be a complete type which is 
-not a function type, if an expression, the expression must have a single 
+`sizeof` and `alignof` expressions take either a type or an expression as an 
+argument; if the argument is a type, it must be a complete type which is not a 
+function type, if an expression, the expression must have a single 
 interpretation, the type of which conforms to the same rules. 
 `offsetof` takes two arguments, a type and a member name; the type must be 
@@ -1620 +1620 @@
                         = delete;
         }
+
+## Appendix E: Features to Add in Resolver Re-write ##
+* Reference types
+* Special types for 0 and 1 literals
+* Expression type for return statement that resolves similarly to ?=?
+  - This is to get rid of the kludge in the box pass that effectively 
+    re-implements the resolver poorly.