Index: doc/working/resolver_design.md
===================================================================
--- doc/working/resolver_design.md (revision ff3fc936860505713ed81ebb530f81e2656a37d0)
+++ doc/working/resolver_design.md (revision ac43954180f13a25ad6ec84de6b73da43f6f9223)
@@ -37,5 +37,5 @@
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,5 +69,5 @@
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,5 +509,5 @@
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,5 +577,5 @@
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,7 +951,7 @@
`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,2 +1620,9 @@
= 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.