code: public Decl.Type parseTypeDeclaration(Tuple<Modifier> modifiers) {
  		int start = index;
  		EnclosingScope scope = new EnclosingScope();
  		//
  		match(Identifier); // type
  		// Parse type name
  		Identifier name = parseIdentifier();
  		// Parse templare variables
  		Tuple<Template.Variable> template = parseOptionalTemplate(scope);
  		match(Is);
  		// Parse the type pattern
  		Decl.Variable var = parseOptionalParameter(scope);
  		addFieldAliases(var, scope);
  		Tuple<Expr> invariant = parseInvariant(scope, Where);
  		int end = index;
  		matchEndLine();
  		return annotateSourceLocation(new Decl.Type(modifiers, name, template, var, invariant), start);
  	}
docs: Parse a type declaration in a Whiley source file, which has the form:
  
  <pre>
  "type" Identifier "is" TypePattern ("where" Expr)*
  </pre>
  
  Here, the type pattern specifies a type which may additionally be adorned
  with variable names. The "where" clause is optional and is often referred
  to as the type's "constraint". Variables defined within the type pattern
  may be used within this constraint expressions. A simple example to
  illustrate is:
  
  <pre>
  type nat is (int x) where x >= 0
  </pre>
  
  Here, we are defining a <i>constrained type</i> called <code>nat</code>
  which represents the set of natural numbers (i.e the non-negative
  integers). Type declarations may also have modifiers, such as
  <code>public</code> and <code>private</code>.
  
  @see wyil.lang.WyilFile.Type
  
  @param modifiers
  --- The list of modifiers for this declaration (which were
  already parsed before this method was called).