Rename Type -> type, per #2360. (#2507)

Also make minor updates to the skeletal design in
docs/design/name_lookup.md following #2113, as there are no longer any prelude names that are made available to unqualified name lookup by default.

Add `type` to the keyword list in
docs/design/lexical_conventions/words.md, following #2360.

Author: zygoloid

common/fuzzing/proto_to_carbon.cpp

@@ -371,7 +371,7 @@ static auto ExpressionToCarbon(const Fuzzing::Expression& expression,
       break;
 
     case Fuzzing::Expression::kTypeTypeLiteral:
-      out << "Type";
+      out << "type";
       break;
 
     case Fuzzing::Expression::kUnimplementedExpression:

docs/design/README.md

@@ -2583,10 +2583,10 @@ given any type `T` that implements the `Ordered` interface. Subsequent calls to
 `Ordered`.
 
 The parameter could alternatively be declared to be a _template_ generic
-parameter by prefixing with the `template` keyword, as in `template T:! Type`.
+parameter by prefixing with the `template` keyword, as in `template T:! type`.
 
 ```carbon
-fn Convert[template T:! Type](source: T, template U:! Type) -> U {
+fn Convert[template T:! type](source: T, template U:! type) -> U {
   var converted: U = source;
   return converted;
 }
@@ -2621,7 +2621,7 @@ declaration, and the condition can only use constant values known at
 type-checking time, including `template` parameters.
 
 ```carbon
-class Array(template T:! Type, template N:! i64)
+class Array(template T:! type, template N:! i64)
     if N >= 0 and N < MaxArraySize / sizeof(T);
 ```
 
@@ -2630,7 +2630,7 @@ provided by the caller, _in addition_ to any constraints. This means member name
 lookup and type checking for anything
 [dependent](generics/terminology.md#dependent-names) on the template parameter
 can't be completed until the template is instantiated with a specific concrete
-type. When the constraint is just `Type`, this gives semantics similar to C++
+type. When the constraint is just `type`, this gives semantics similar to C++
 templates. Constraints can then be added incrementally, with the compiler
 verifying that the semantics stay the same. Once all constraints have been
 added, removing the word `template` to switch to a checked parameter is safe.
@@ -2825,7 +2825,7 @@ to a class must be generic, and so defined with `:!`, either with or without the
 type `T`:
 
 ```carbon
-class Stack(T:! Type) {
+class Stack(T:! type) {
   fn Push[addr self: Self*](value: T);
   fn Pop[addr self: Self*]() -> T;
 
@@ -2847,7 +2847,7 @@ The values of type parameters are part of a type's value, and so may be deduced
 in a function call, as in this example:
 
 ```carbon
-fn PeekTopOfStack[T:! Type](s: Stack(T)*) -> T {
+fn PeekTopOfStack[T:! type](s: Stack(T)*) -> T {
   var top: T = s->Pop();
   s->Push(top);
   return top;
@@ -2868,7 +2868,7 @@ PeekTopOfStack(&int_stack);
 [Choice types](#choice-types) may be parameterized similarly to classes:
 
 ```carbon
-choice Result(T:! Type, Error:! Type) {
+choice Result(T:! type, Error:! type) {
   Success(value: T),
   Failure(error: Error)
 }
@@ -2880,7 +2880,7 @@ Interfaces are always parameterized by a `Self` type, but in some cases they
 will have additional parameters.
 
 ```carbon
-interface AddWith(U:! Type);
+interface AddWith(U:! type);
 ```
 
 Interfaces without parameters may only be implemented once for a given type, but
@@ -2904,11 +2904,11 @@ parameter list_`]` after the `impl` keyword introducer, as in:
 
 ```carbon
 external impl forall [T:! Printable] Vector(T) as Printable;
-external impl forall [Key:! Hashable, Value:! Type]
+external impl forall [Key:! Hashable, Value:! type]
     HashMap(Key, Value) as Has(Key);
 external impl forall [T:! Ordered] T as PartiallyOrdered;
 external impl forall [T:! ImplicitAs(i32)] BigInt as AddWith(T);
-external impl forall [U:! Type, T:! As(U)]
+external impl forall [U:! type, T:! As(U)]
     Optional(T) as As(Optional(U));
 ```
 
@@ -3123,7 +3123,7 @@ There are some situations where the common type for two types is needed:
     will be set to the common type of the corresponding arguments, as in:
 
     ```carbon
-    fn F[T:! Type](x: T, y: T);
+    fn F[T:! type](x: T, y: T);
 
     // Calls `F` with `T` set to the
     // common type of `G()` and `H()`:

docs/design/classes.md

@@ -1084,7 +1084,7 @@ Other type constants can be defined using a `let` declaration:
 ```
 class MyClass {
   let Pi:! f32 = 3.141592653589793;
-  let IndexType:! Type = i32;
+  let IndexType:! type = i32;
 }
 ```
 

docs/design/expressions/arithmetic.md

@@ -193,15 +193,15 @@ following family of interfaces:
 ```
 // Unary `-`.
 interface Negate {
-  let Result:! Type = Self;
+  let Result:! type = Self;
   fn Op[self: Self]() -> Result;
 }
 ```
 
 ```
 // Binary `+`.
-interface AddWith(U:! Type) {
-  let Result:! Type = Self;
+interface AddWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint Add {
@@ -211,8 +211,8 @@ constraint Add {
 
 ```
 // Binary `-`.
-interface SubWith(U:! Type) {
-  let Result:! Type = Self;
+interface SubWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint Sub {
@@ -222,8 +222,8 @@ constraint Sub {
 
 ```
 // Binary `*`.
-interface MulWith(U:! Type) {
-  let Result:! Type = Self;
+interface MulWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint Mul {
@@ -233,8 +233,8 @@ constraint Mul {
 
 ```
 // Binary `/`.
-interface DivWith(U:! Type) {
-  let Result:! Type = Self;
+interface DivWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint Div {
@@ -244,8 +244,8 @@ constraint Div {
 
 ```
 // Binary `%`.
-interface ModWith(U:! Type) {
-  let Result:! Type = Self;
+interface ModWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint Mod {

docs/design/expressions/as_expressions.md

@@ -78,7 +78,7 @@ var m: auto = b as T as U;
 ```
 
 **Note:** `b as (bool as Hashable)` is valid but not useful, because
-[the second operand of `as` is implicitly converted to type `Type`](#extensibility).
+[the second operand of `as` is implicitly converted to type `type`](#extensibility).
 This expression therefore has the same interpretation as `b as bool`.
 
 **TODO:** We should consider making `as` expressions left-associative now that
@@ -164,15 +164,15 @@ Explicit casts can be defined for user-defined types such as
 [classes](../classes.md) by implementing the `As` interface:
 
 ```
-interface As(Dest:! Type) {
+interface As(Dest:! type) {
   fn Convert[self: Self]() -> Dest;
 }
 ```
 
 The expression `x as U` is rewritten to `x.(As(U).Convert)()`.
 
 **Note:** This rewrite causes the expression `U` to be implicitly converted to
-type `Type`. The program is invalid if this conversion is not possible.
+type `type`. The program is invalid if this conversion is not possible.
 
 ## Alternatives considered
 

docs/design/expressions/bitwise.md

@@ -197,15 +197,15 @@ implementing the following family of interfaces:
 ```
 // Unary `^`.
 interface BitComplement {
-  let Result:! Type = Self;
+  let Result:! type = Self;
   fn Op[self: Self]() -> Result;
 }
 ```
 
 ```
 // Binary `&`.
-interface BitAndWith(U:! Type) {
-  let Result:! Type = Self;
+interface BitAndWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint BitAnd {
@@ -215,8 +215,8 @@ constraint BitAnd {
 
 ```
 // Binary `|`.
-interface BitOrWith(U:! Type) {
-  let Result:! Type = Self;
+interface BitOrWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint BitOr {
@@ -226,8 +226,8 @@ constraint BitOr {
 
 ```
 // Binary `^`.
-interface BitXorWith(U:! Type) {
-  let Result:! Type = Self;
+interface BitXorWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint BitXor {
@@ -237,8 +237,8 @@ constraint BitXor {
 
 ```
 // Binary `<<`.
-interface LeftShiftWith(U:! Type) {
-  let Result:! Type = Self;
+interface LeftShiftWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint LeftShift {
@@ -248,8 +248,8 @@ constraint LeftShift {
 
 ```
 // Binary `>>`.
-interface RightShiftWith(U:! Type) {
-  let Result:! Type = Self;
+interface RightShiftWith(U:! type) {
+  let Result:! type = Self;
   fn Op[self: Self](other: U) -> Result;
 }
 constraint RightShift {

docs/design/expressions/comparison_operators.md

@@ -253,7 +253,7 @@ The `EqWith` interface is used to define the semantics of the `==` and `!=`
 operators for a given pair of types:
 
 ```
-interface EqWith(U:! Type) {
+interface EqWith(U:! type) {
   fn Equal[self: Self](u: U) -> bool;
   default fn NotEqual[self: Self](u: U) -> bool {
     return not (self == u);
@@ -353,7 +353,7 @@ choice Ordering {
   Greater,
   Incomparable
 }
-interface OrderedWith(U:! Type) {
+interface OrderedWith(U:! type) {
   fn Compare[self: Self](u: U) -> Ordering;
   default fn Less[self: Self](u: U) -> bool {
     return self.Compare(u) == Ordering.Less;
@@ -432,7 +432,7 @@ implemented. The behaviors of such overrides should follow those of the above
 default implementations, and the members of an `OrderedWith` implementation
 should have no observable side-effects.
 
-`OrderedWith` implementations should be _transitive_. That is, given `V:! Type`,
+`OrderedWith` implementations should be _transitive_. That is, given `V:! type`,
 `U:! OrderedWith(V)`, `T:! OrderedWith(U) & OrderedWith(V)`, `a: T`, `b: U`,
 `c: V`, then:
 

docs/design/expressions/if.md

@@ -87,8 +87,8 @@ The interface `CommonTypeWith` is used to customize the behavior of
 `CommonType`:
 
 ```
-interface CommonTypeWith(U:! Type) {
-  let Result:! Type
+interface CommonTypeWith(U:! type) {
+  let Result:! type
     where Self is ImplicitAs(.Self) and
           U is ImplicitAs(.Self);
 }
@@ -120,15 +120,15 @@ The interface `SymmetricCommonTypeWith` is an implementation detail of the
 `CommonType` constraint. It is defined and implemented as follows:
 
 ```
-interface SymmetricCommonTypeWith(U:! Type) {
-  let Result:! Type
+interface SymmetricCommonTypeWith(U:! type) {
+  let Result:! type
     where Self is ImplicitAs(.Self) and
           U is ImplicitAs(.Self);
 }
 match_first {
-  impl forall [T:! Type, U:! CommonTypeWith(T)]
+  impl forall [T:! type, U:! CommonTypeWith(T)]
       T as SymmetricCommonTypeWith(U) where .Result = U.Result {}
-  impl forall [U:! Type, T:! CommonTypeWith(U)]
+  impl forall [U:! type, T:! CommonTypeWith(U)]
       T as SymmetricCommonTypeWith(U) where .Result = T.Result {}
 }
 ```
@@ -152,10 +152,10 @@ the `CommonType` constraint is not met. For example, given:
 
 ```
 // Implementation #1
-impl forall [T:! Type] MyX as CommonTypeWith(T) where .Result = MyX {}
+impl forall [T:! type] MyX as CommonTypeWith(T) where .Result = MyX {}
 
 // Implementation #2
-impl forall [T:! Type] MyY as CommonTypeWith(T) where .Result = MyY {}
+impl forall [T:! type] MyY as CommonTypeWith(T) where .Result = MyY {}
 ```
 
 `MyX as CommonTypeWith(MyY)` will select #1, and `MyY as CommonTypeWith(MyX)`
@@ -167,15 +167,15 @@ because result types differ.
 If `T` is the same type as `U`, the result is that type:
 
 ```
-final impl forall [T:! Type] T as CommonTypeWith(T) where .Result = T {}
+final impl forall [T:! type] T as CommonTypeWith(T) where .Result = T {}
 ```
 
 _Note:_ This rule is intended to be considered more specialized than the other
 rules in this document.
 
 Because this `impl` is declared `final`, `T.(CommonType(T)).Result` is always
 assumed to be `T`, even in contexts where `T` involves a generic parameter and
-so the result would normally be an unknown type whose type-of-type is `Type`.
+so the result would normally be an unknown type whose type-of-type is `type`.
 
 ```
 fn F[T:! Hashable](c: bool, x: T, y: T) -> HashCode {
@@ -189,7 +189,7 @@ fn F[T:! Hashable](c: bool, x: T, y: T) -> HashCode {
 If `T` implicitly converts to `U`, the common type is `U`:
 
 ```
-impl forall [T:! Type, U:! ImplicitAs(T)]
+impl forall [T:! type, U:! ImplicitAs(T)]
     T as CommonTypeWith(U) where .Result = T {}
 ```
 

docs/design/expressions/implicit_conversions.md

@@ -207,7 +207,7 @@ extends
 [the `As` interface used to implement `as` expressions](as_expressions.md#extensibility):
 
 ```
-interface ImplicitAs(Dest:! Type) {
+interface ImplicitAs(Dest:! type) {
   extends As(Dest);
   // Inherited from As(Dest):
   // fn Convert[self: Self]() -> Dest;