convert parseType to take a DiagID.

Swift SVN r762

include/swift/Basic/Diagnostics.def

@@ -86,6 +86,8 @@ ERROR(decl_expected_module_name,decl_parsing,none,
       "expected module name in import declaration", ())
 
 // TypeAlias
+ERROR(expected_type_in_typealias,decl_parsing,none,
+      "expected type in var declaration", ())
 
 // Func
 ERROR(func_decl_without_paren,decl_parsing,none,
@@ -102,12 +104,24 @@ ERROR(struct_not_tuple,decl_parsing,none,
 //------------------------------------------------------------------------------
 // Type parsing diagnostics
 //------------------------------------------------------------------------------
+
+ERROR(expected_type,type_parsing,none,
+      "expected type", ())
+ERROR(expected_type_function_result,type_parsing,none,
+      "expected type for function result", ())
+
+// oneof Types      
 ERROR(duplicate_oneof_element,type_parsing,none,
       "duplicate definition of element '%0'", (StringRef))
+ERROR(expected_type_oneof_element,type_parsing,none,
+      "expected type while parsing oneof element", ())
+
+// Array Types      
 ERROR(non_constant_array,type_parsing,none,
       "array has non-constant size", ())
 ERROR(zero_length_array,type_parsing,none,
       "array has length zero", ())
+      
 ERROR(expected_protocol_member,type_parsing,none,
       "expected a function or variable declaration in protocol", ())
 ERROR(type_redefinition,type_parsing,none,

lib/Parse/ParseDecl.cpp

@@ -262,7 +262,7 @@ TypeAliasDecl *Parser::parseDeclTypeAlias() {
   Type Ty;
   if (parseIdentifier(Id, diags::expected_identifier_in_decl, "typealias") ||
       parseToken(tok::colon, "expected ':' in typealias declaration") ||
-      parseType(Ty, "expected type in var declaration"))
+      parseType(Ty, diags::expected_type_in_typealias))
     return 0;
 
   return ScopeInfo.addTypeAliasToScope(TypeAliasLoc, Id, Ty);

lib/Parse/ParseType.cpp

@@ -21,7 +21,7 @@
 using namespace swift;
 
 bool Parser::parseType(Type &Result) {
-  return parseType(Result, "expected type");
+  return parseType(Result, diags::expected_type);
 }
 
 /// parseType
@@ -43,7 +43,7 @@ bool Parser::parseType(Type &Result) {
 ///     identifier
 ///     scope-qualifier identifier
 ///
-bool Parser::parseType(Type &Result, const Twine &Message) {
+bool Parser::parseType(Type &Result, Diag<> MessageID) {
   // Parse type-simple first.
   switch (Tok.getKind()) {
   case tok::identifier: {
@@ -87,7 +87,7 @@ bool Parser::parseType(Type &Result, const Twine &Message) {
       return true;
     break;
   default:
-    error(Tok.getLoc(), Message);
+    diagnose(Tok.getLoc(), MessageID);
     return true;
   }
   
@@ -96,7 +96,7 @@ bool Parser::parseType(Type &Result, const Twine &Message) {
     SourceLoc TokLoc = Tok.getLoc();
     if (consumeIf(tok::arrow)) {
       Type SecondHalf;
-      if (parseType(SecondHalf, "expected type in result of function type"))
+      if (parseType(SecondHalf, diags::expected_type_function_result))
         return true;
       Result = FunctionType::get(Result, SecondHalf, Context);
       continue;
@@ -221,9 +221,7 @@ bool Parser::parseTypeOneOfBody(SourceLoc OneOfLoc, const DeclAttributes &Attrs,
     
     // See if we have a type specifier for this oneof element.  If so, parse it.
     if (consumeIf(tok::colon) &&
-        parseType(ElementInfo.EltType,
+        parseType(ElementInfo.EltType, diags::expected_type_oneof_element)) {
-                  "expected type while parsing oneof element '" +
-                  ElementInfo.Name + "'")) {
       skipUntil(tok::r_brace);
       return true;
     }

lib/Parse/Parser.cpp

@@ -133,7 +133,7 @@ bool Parser::parseValueSpecifier(Type &Ty, NullablePtr<Expr> &Init,
   
   // Parse the type if present.
   if (consumeIf(tok::colon) &&
-      parseType(Ty, "expected type in var declaration"))
+      parseType(Ty, diags::expected_type))
     return true;
   
   // Parse the initializer, if present.

lib/Parse/Parser.h

@@ -189,7 +189,7 @@ public:
   // Type Parsing
   
   bool parseType(Type &Result);
-  bool parseType(Type &Result, const Twine &Message);
+  bool parseType(Type &Result, Diag<> ID);
   bool parseTypeTupleBody(SourceLoc LPLoc, Type &Result);
   
   bool parseTypeOneOf(Type &Result);