[flang][fir] Add FIR Types parser diagnostic tests + cleanup

[clementval]

Summary

Add diagnostic tests for Types parsers and remove duplicated diagnostics handled by the MLIR
parser.

[clementval]

Rebase + format

flang/lib/Optimizer/Dialect/FIRType.cpp

 
 using namespace fir;
 
 namespace {
 
 template <typename TYPE>
 TYPE parseIntSingleton(mlir::DialectAsmParser &parser) {
   int kind = 0;
-  if (parser.parseLess() || parser.parseInteger(kind) ||
-      parser.parseGreater()) {
-    parser.emitError(parser.getCurrentLocation(), "kind value expected");
+  if (parser.parseLess() || parser.parseInteger(kind) || parser.parseGreater())
     return {};
-  }
   return TYPE::get(parser.getBuilder().getContext(), kind);
 }
 
 template <typename TYPE>
 TYPE parseKindSingleton(mlir::DialectAsmParser &parser) {
   return parseIntSingleton<TYPE>(parser);
 }
 
 template <typename TYPE>
 TYPE parseRankSingleton(mlir::DialectAsmParser &parser) {
   return parseIntSingleton<TYPE>(parser);
 }
 
 template <typename TYPE>
 TYPE parseTypeSingleton(mlir::DialectAsmParser &parser) {
   mlir::Type ty;
-  if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {
-    parser.emitError(parser.getCurrentLocation(), "type expected");
+  if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater())
     return {};
-  }
   return TYPE::get(ty);
 }
 
 /// Is `ty` a standard or FIR integer type?
 static bool isaIntegerType(mlir::Type ty) {
   // TODO: why aren't we using isa_integer? investigatation required.
   return ty.isa<mlir::IntegerType>() || ty.isa<fir::IntegerType>();
 }
 
 bool verifyRecordMemberType(mlir::Type ty) {
   return !(ty.isa<BoxType>() || ty.isa<BoxCharType>() ||
            ty.isa<BoxProcType>() || ty.isa<ShapeType>() ||
-           ty.isa<ShapeShiftType>() || ty.isa<SliceType>() ||
-           ty.isa<FieldType>() || ty.isa<LenType>() ||
+           ty.isa<ShapeShiftType>() || ty.isa<ShiftType>() ||
+           ty.isa<SliceType>() || ty.isa<FieldType>() || ty.isa<LenType>() ||
            ty.isa<ReferenceType>() || ty.isa<TypeDescType>());
 }
 
 bool verifySameLists(llvm::ArrayRef<RecordType::TypePair> a1,
                      llvm::ArrayRef<RecordType::TypePair> a2) {
   // FIXME: do we need to allow for any variance here?
   return a1 == a2;
 }

 } // namespace
 
 // Implementation of the thin interface from dialect to type parser
 
 mlir::Type fir::parseFirType(FIROpsDialect *dialect,
                              mlir::DialectAsmParser &parser) {
   llvm::StringRef typeNameLit;
   if (mlir::failed(parser.parseKeyword(&typeNameLit)))
-    return mlir::Type();
-
+    return {};
   return generatedTypeParser(dialect->getContext(), parser, typeNameLit);
 }
 
 namespace fir {
 namespace detail {
 
 // Type storage classes
 

 //===----------------------------------------------------------------------===//
 // BoxProcType
 //===----------------------------------------------------------------------===//
 
 // `boxproc` `<` return-type `>`
 mlir::Type BoxProcType::parse(mlir::MLIRContext *context,
                               mlir::DialectAsmParser &parser) {
   mlir::Type ty;
-  if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {
-    parser.emitError(parser.getCurrentLocation(), "type expected");
+  if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater())
     return {};
-  }
   return get(context, ty);
 }
 
 void fir::BoxProcType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getEleTy() << '>';
 }
 
 mlir::LogicalResult

 //===----------------------------------------------------------------------===//
 // BoxType
 //===----------------------------------------------------------------------===//
 
 // `box` `<` type (',' affine-map)? `>`
 mlir::Type fir::BoxType::parse(mlir::MLIRContext *context,
                                mlir::DialectAsmParser &parser) {
   mlir::Type ofTy;
-  if (parser.parseLess() || parser.parseType(ofTy)) {
-    parser.emitError(parser.getCurrentLocation(), "expected type parameter");
+  if (parser.parseLess() || parser.parseType(ofTy))
     return {};
-  }
 
   mlir::AffineMapAttr map;
   if (!parser.parseOptionalComma()) {
     if (parser.parseAttribute(map)) {
       parser.emitError(parser.getCurrentLocation(), "expected affine map");
       return {};
     }
   }
-  if (parser.parseGreater()) {
+  if (parser.parseGreater())
     return {};
-  }
   return get(ofTy, map);
 }
 
 void fir::BoxType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getEleTy();
   if (auto map = getLayoutMap()) {
     printer << ", " << map;
   }
   printer << '>';
 }
 
 mlir::LogicalResult
 fir::BoxType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
                      mlir::Type eleTy, mlir::AffineMapAttr map) {
   // TODO
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // BoxCharType
 //===----------------------------------------------------------------------===//
 
 mlir::Type fir::BoxCharType::parse(mlir::MLIRContext *context,
                                    mlir::DialectAsmParser &parser) {
-  int kind = 0;
-  if (parser.parseLess() || parser.parseInteger(kind) ||
-      parser.parseGreater()) {
-    parser.emitError(parser.getCurrentLocation(), "kind value expected");
-    return {};
-  }
-  return get(context, kind);
+  return parseKindSingleton<fir::BoxCharType>(parser);
 }
 
 void fir::BoxCharType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getKind() << ">";
 }
 
 CharacterType
 fir::BoxCharType::getElementType(mlir::MLIRContext *context) const {
   return CharacterType::getUnknownLen(context, getKind());
 }
 
 CharacterType fir::BoxCharType::getEleTy() const {
   return getElementType(getContext());
 }
 
 //===----------------------------------------------------------------------===//
 // CharacterType
 //===----------------------------------------------------------------------===//
 
 // `char` `<` kind [`,` `len`] `>`
 mlir::Type fir::CharacterType::parse(mlir::MLIRContext *context,
                                      mlir::DialectAsmParser &parser) {
   int kind = 0;
-  if (parser.parseLess() || parser.parseInteger(kind)) {
-    parser.emitError(parser.getCurrentLocation(), "kind value expected");
+  if (parser.parseLess() || parser.parseInteger(kind))
     return {};
-  }
   CharacterType::LenType len = 1;
   if (mlir::succeeded(parser.parseOptionalComma())) {
     if (mlir::succeeded(parser.parseOptionalQuestion())) {
       len = fir::CharacterType::unknownLen();
     } else if (!mlir::succeeded(parser.parseInteger(len))) {
-      parser.emitError(parser.getCurrentLocation(), "len value expected");
       return {};
     }
   }
   if (parser.parseGreater())
     return {};
   return get(context, kind, len);
 }
 

 
 // Fortran derived type
 // `type` `<` name
 //           (`(` id `:` type (`,` id `:` type)* `)`)?
 //           (`{` id `:` type (`,` id `:` type)* `}`)? '>'
 mlir::Type fir::RecordType::parse(mlir::MLIRContext *context,
                                   mlir::DialectAsmParser &parser) {
   llvm::StringRef name;
-  if (parser.parseLess() || parser.parseKeyword(&name)) {
-    parser.emitError(parser.getNameLoc(),
-                     "expected a identifier as name of derived type");
+  if (parser.parseLess() || parser.parseKeyword(&name))
     return {};
-  }
   RecordType result = RecordType::get(parser.getBuilder().getContext(), name);
 
   RecordType::TypeList lenParamList;
   if (!parser.parseOptionalLParen()) {
     while (true) {
       llvm::StringRef lenparam;
       mlir::Type intTy;
       if (parser.parseKeyword(&lenparam) || parser.parseColon() ||
           parser.parseType(intTy)) {
         parser.emitError(parser.getNameLoc(), "expected LEN parameter list");
         return {};
       }
       lenParamList.emplace_back(lenparam, intTy);
       if (parser.parseOptionalComma())
         break;
     }
-    if (parser.parseRParen()) {
-      parser.emitError(parser.getNameLoc(), "expected ')'");
+    if (parser.parseRParen())
       return {};
-    }
-  }
 
   RecordType::TypeList typeList;
   if (!parser.parseOptionalLBrace()) {
     while (true) {
       llvm::StringRef field;
       mlir::Type fldTy;
       if (parser.parseKeyword(&field) || parser.parseColon() ||
           parser.parseType(fldTy)) {
         parser.emitError(parser.getNameLoc(), "expected field type list");
         return {};
       }
       typeList.emplace_back(field, fldTy);
       if (parser.parseOptionalComma())
         break;
     }
-    if (parser.parseRBrace()) {
-      parser.emitError(parser.getNameLoc(), "expected '}'");
+    if (parser.parseRBrace())
       return {};
-    }
-  }
 
-  if (parser.parseGreater()) {
-    parser.emitError(parser.getNameLoc(), "expected '>' in type type");
+  if (parser.parseGreater())
     return {};
-  }
 
   if (lenParamList.empty() && typeList.empty())
     return result;
 
   result.finalize(lenParamList, typeList);
   return verifyDerived(parser, result, lenParamList, typeList);
 }
 

 //===----------------------------------------------------------------------===//
 // SequenceType
 //===----------------------------------------------------------------------===//
 
 // `array` `<` `*` | bounds (`x` bounds)* `:` type (',' affine-map)? `>`
 // bounds ::= `?` | int-lit
 mlir::Type fir::SequenceType::parse(mlir::MLIRContext *context,
                                     mlir::DialectAsmParser &parser) {
-  if (parser.parseLess()) {
-    parser.emitError(parser.getNameLoc(), "expecting '<'");
+  if (parser.parseLess())
     return {};
-  }
   SequenceType::Shape shape;
   if (parser.parseOptionalStar()) {
-    if (parser.parseDimensionList(shape, /*allowDynamic=*/true)) {
-      parser.emitError(parser.getNameLoc(), "invalid shape");
+    if (parser.parseDimensionList(shape, /*allowDynamic=*/true))
       return {};
-    }
   } else if (parser.parseColon()) {
-    parser.emitError(parser.getNameLoc(), "expected ':'");
     return {};
   }
   mlir::Type eleTy;
-  if (parser.parseType(eleTy) || parser.parseGreater()) {
-    parser.emitError(parser.getNameLoc(), "expecting element type");
+  if (parser.parseType(eleTy) || parser.parseGreater())
     return {};
-  }
   mlir::AffineMapAttr map;
   if (!parser.parseOptionalComma())
     if (parser.parseAttribute(map)) {
       parser.emitError(parser.getNameLoc(), "expecting affine map");
       return {};
     }
   return SequenceType::get(context, shape, eleTy, map);
 }

 //===----------------------------------------------------------------------===//
 
 // `vector` `<` len `:` type `>`
 mlir::Type fir::VectorType::parse(mlir::MLIRContext *context,
                                   mlir::DialectAsmParser &parser) {
   int64_t len = 0;
   mlir::Type eleTy;
   if (parser.parseLess() || parser.parseInteger(len) || parser.parseColon() ||
-      parser.parseType(eleTy) || parser.parseGreater()) {
-    parser.emitError(parser.getNameLoc(), "invalid vector type");
+      parser.parseType(eleTy) || parser.parseGreater())
     return {};
-  }
   return fir::VectorType::get(len, eleTy);
 }
 
 void fir::VectorType::print(mlir::DialectAsmPrinter &printer) const {
   printer << getMnemonic() << "<" << getLen() << ':' << getEleTy() << '>';
 }
 
 mlir::LogicalResult fir::VectorType::verify(

flang/test/Fir/invalid-types.fir

+// Test the FIR types parser diagnostics
+// RUN: fir-opt -split-input-file -verify-diagnostics %s
+
+// expected-error@+1 {{expected non-function type}}
+func private @box3() -> !fir.boxproc<>
+
+// -----
+
+// expected-error@+2 {{expected non-function type}}
+// expected-error@+1 {{expected affine map}}
+func private @box1() -> !fir.box<!fir.array<?xf32>, >
+
+// -----
+
+// expected-error@+1 {{expected non-function type}}
+func private @box1() -> !fir.box<>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @box2() -> !fir.boxchar<>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @it6() -> !fir.char<>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @it6() -> !fir.char<2, >
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @it3() -> !fir.complex<>
+
+// -----
+
+// expected-error@+1 {{expected non-function type}}
+func private @mem3() -> !fir.heap<>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @it1() -> !fir.int<A>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @it1() -> !fir.logical<b>
+
+// -----
+
+// expected-error@+1 {{expected non-function type}}
+func private @mem3() -> !fir.ptr<>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @mem3() -> !fir.real<>
+
+// -----
+
+// expected-error@+1 {{expected valid keyword}}
+func private @mem3() -> !fir.type<>
+
+// -----
+
+// expected-error@+2 {{expected valid keyword}}
+// expected-error@+1 {{expected LEN parameter list}}
+func private @dvd4() -> !fir.type<derived4()>
+
+// -----
+
+// expected-error@+2 {{expected ':'}}
+// expected-error@+1 {{expected LEN parameter list}}
+func private @dvd4() -> !fir.type<derived4(p)>
+
+// -----
+
+// expected-error@+2 {{expected non-function type}}
+// expected-error@+1 {{expected LEN parameter list}}
+func private @dvd4() -> !fir.type<derived4(p:)>
+
+// -----
+
+// expected-error@+2 {{expected valid keyword}}
+// expected-error@+1 {{expected field type list}}
+func private @dvd4() -> !fir.type<derived4(p:i8){}>
+
+// -----
+
+// expected-error@+2 {{expected ':'}}
+// expected-error@+1 {{expected field type list}}
+func private @dvd4() -> !fir.type<derived4(p:i8){f1}>
+
+// -----
+
+// expected-error@+2 {{expected non-function type}}
+// expected-error@+1 {{expected field type list}}
+func private @dvd4() -> !fir.type<derived4(p:i8){f1:f2}>
+
+// -----
+
+// expected-error@+2 {{expected valid keyword}}
+// expected-error@+1 {{expected field type list}}
+func private @dvd4() -> !fir.type<derived4(p:i8){f1:i32,}>
+
+// -----
+
+// expected-error@+2 {{expected valid keyword}}
+// expected-error@+1 {{expected field type list}}
+func private @dvd4() -> !fir.type<derived4(p:i8){,}>
+
+// -----
+
+// expected-error@+1 {{expected non-function type}}
+func private @mem3() -> !fir.ref<>
+
+// -----
+
+// expected-error@+1 {{expected ':'}}
+func private @arr1() -> !fir.array<*>
+
+// -----
+
+// expected-error@+1 {{expected non-function type}}
+func private @arr1() -> !fir.array<*:>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @oth1() -> !fir.shape<>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @oth1() -> !fir.shapeshift<>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @oth1() -> !fir.shift<>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @oth1() -> !fir.slice<>
+
+// -----
+
+// expected-error@+1 {{expected non-function type}}
+func private @oth3() -> !fir.tdesc<xx>
+
+// -----
+
+// expected-error@+1 {{expected integer value}}
+func private @oth3() -> !fir.vector<>
+
+// -----
+
+// expected-error@+1 {{expected ':'}}
+func private @oth3() -> !fir.vector<10>
+
+// -----
+
+// expected-error@+1 {{expected non-function type}}
+func private @oth3() -> !fir.vector<10:>