checkpoint

Author: ashermancinelli

flang/include/flang/Optimizer/Dialect/FIRTypes.td

@@ -366,23 +366,20 @@ def fir_ReferenceType : FIR_Type<"Reference", "ref"> {
 
   let parameters = (ins
     "mlir::Type":$eleTy,
-    DefaultValuedParameter<"bool", "false">:$isVol,
-    DefaultValuedParameter<"bool", "false">:$isAsync);
+    DefaultValuedParameter<"bool", "false">:$isVol);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
-    TypeBuilderWithInferredContext<(ins "mlir::Type":$elementType, CArg<"bool", "false">:$isVol, CArg<"bool", "false">:$isAsync), [{
-      return Base::get(elementType.getContext(), elementType, isVol, isAsync);
+    TypeBuilderWithInferredContext<(ins "mlir::Type":$elementType, CArg<"bool", "false">:$isVol), [{
+      return Base::get(elementType.getContext(), elementType, isVol);
     }]>,
   ];
 
   let extraClassDeclaration = [{
     mlir::Type getElementType() const { return getEleTy(); }
     bool isVolatile() const { return (bool)getIsVol(); }
-    bool isAsync() const { return (bool)getIsAsync(); }
     static llvm::StringRef getVolatileKeyword() { return "volatile"; }
-    static llvm::StringRef getAsyncKeyword() { return "async"; }
   }];
 
   let genVerifyDecl = 1;

flang/lib/Lower/CallInterface.cpp

@@ -1112,7 +1112,6 @@ class Fortran::lower::CallInterfaceImpl {
     if (obj.attrs.test(Attrs::Value))
       isValueAttr = true; // TODO: do we want an mlir::Attribute as well?
     if (obj.attrs.test(Attrs::Volatile)) {
-      // TODO(loc, "VOLATILE in procedure interface");
       addMLIRAttr(fir::getVolatileAttrName());
     }
     // obj.attrs.test(Attrs::Asynchronous) does not impact the way the argument

flang/lib/Lower/ConvertExprToHLFIR.cpp

@@ -224,8 +224,7 @@ class HlfirDesignatorBuilder {
             /*namedConstantSectionsAreAlwaysContiguous=*/false))
       return fir::BoxType::get(resultValueType);
 
-    // TODO: handle async references
-    bool isVolatile = false, isAsync = false;
+    bool isVolatile = false;
 
     // Check if the base type is volatile
     if (partInfo.base.has_value()) {
@@ -247,13 +246,13 @@ class HlfirDesignatorBuilder {
       if (isVolatileSymbol(designatorNode.GetLastSymbol()))
         isVolatile = true;
     }
-    
+
     // If it's a reference to a ref, account for it
     if (auto refTy = mlir::dyn_cast<fir::ReferenceType>(resultValueType))
       resultValueType = refTy.getEleTy();
 
     // Other designators can be handled as raw addresses.
-    return fir::ReferenceType::get(resultValueType, isVolatile, isAsync);
+    return fir::ReferenceType::get(resultValueType, isVolatile);
   }
 
   template <typename T>
@@ -298,7 +297,6 @@ class HlfirDesignatorBuilder {
         partInfo.componentName, partInfo.componentShape, partInfo.subscripts,
         partInfo.substring, partInfo.complexPart, partInfo.resultShape,
         partInfo.typeParams, attributes);
-    llvm::dbgs() << __FILE__ << ":" << __LINE__ << "\n" << designate << "\n" << designatorType << "\n";
     if (auto elementalAddrOp = getVectorSubscriptElementAddrOp())
       builder.setInsertionPoint(*elementalAddrOp);
     return mlir::cast<fir::FortranVariableOpInterface>(
@@ -1829,7 +1827,6 @@ class HlfirBuilder {
             /*complexPart=*/std::nullopt,
             /*shape=*/mlir::Value{}, /*typeParams=*/mlir::ValueRange{},
             fir::FortranVariableFlagsAttr{});
-        llvm::dbgs() << __LINE__ << " " << newParent << "\n";
         currentParent = hlfir::EntityWithAttributes{newParent};
       }
       valuesAndParents.emplace_back(
@@ -1853,6 +1850,7 @@ class HlfirBuilder {
       assert(compType && "failed to retrieve component type");
       mlir::Value compShape =
           designatorBuilder.genComponentShape(sym, compType);
+      mlir::Type designatorType = builder.getRefType(compType, isVolatile);
 
       mlir::Type fieldElemType = hlfir::getFortranElementType(compType);
       llvm::SmallVector<mlir::Value, 1> typeParams;
@@ -1873,7 +1871,6 @@ class HlfirBuilder {
       // Convert component symbol attributes to variable attributes.
       fir::FortranVariableFlagsAttr attrs =
           Fortran::lower::translateSymbolAttributes(builder.getContext(), sym);
-      mlir::Type designatorType = builder.getRefType(compType, isVolatile);
 
       // Get the component designator.
       auto lhs = builder.create<hlfir::DesignateOp>(
@@ -1882,7 +1879,6 @@ class HlfirBuilder {
           /*substring=*/mlir::ValueRange{},
           /*complexPart=*/std::nullopt,
           /*shape=*/compShape, typeParams, attrs);
-      llvm::dbgs() << __LINE__ << " " << lhs << "\n";
 
       if (attrs && bitEnumContainsAny(attrs.getFlags(),
                                       fir::FortranVariableFlagsEnum::pointer)) {

flang/lib/Optimizer/Builder/HLFIRTools.cpp

@@ -810,9 +810,7 @@ mlir::Type hlfir::getVariableElementType(hlfir::Entity variable) {
     return fir::BoxType::get(eleTy);
   }
   const bool isVolatile = fir::isa_volatile_ref_type(variable.getType());
-  auto newty = fir::ReferenceType::get(eleTy, isVolatile);
-  llvm::dbgs() << __FILE__ << ":" << __LINE__ << "\n" << variable << " " << variable.getType() << " newty:" << newty << " isvol:" << isVolatile << "\n";
-  return newty;
+  return fir::ReferenceType::get(eleTy, isVolatile);
 }
 
 mlir::Type hlfir::getEntityElementType(hlfir::Entity entity) {

flang/lib/Optimizer/Dialect/FIRType.cpp

@@ -1057,41 +1057,39 @@ unsigned fir::RecordType::getFieldIndex(llvm::StringRef ident) {
 // ReferenceType
 //===----------------------------------------------------------------------===//
 
-// `ref` `<` type (, volatile)? (, async)? `>`
+// `ref` `<` type (`, volatile` $volatile^)? (`, async` $async^)? `>`
 mlir::Type fir::ReferenceType::parse(mlir::AsmParser &parser) {
   if (parser.parseLess())
     return {};
+
   mlir::Type eleTy;
   if (parser.parseType(eleTy))
     return {};
+
   bool isVolatile = false;
-  bool isAsync = false;
-  while (parser.parseOptionalComma()) {
+  if (parser.parseOptionalComma()) {
     if (parser.parseOptionalKeyword(getVolatileKeyword())) {
       isVolatile = true;
-    } else if (parser.parseOptionalKeyword(getAsyncKeyword())) {
-      isAsync = true;
     } else {
       return {};
     }
   }
+
   if (parser.parseGreater())
     return {};
-  return ReferenceType::get(eleTy, isVolatile, isAsync);
+  return ReferenceType::get(eleTy, isVolatile);
 }
 
 void fir::ReferenceType::print(mlir::AsmPrinter &printer) const {
   printer << "<" << getEleTy();
   if (isVolatile())
     printer << ", volatile";
-  if (isAsync())
-    printer << ", async";
   printer << '>';
 }
 
 llvm::LogicalResult fir::ReferenceType::verify(
     llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
-    mlir::Type eleTy, bool isVolatile, bool isAsync) {
+    mlir::Type eleTy, bool isVolatile) {
   if (mlir::isa<ShapeType, ShapeShiftType, SliceType, FieldType, LenType,
                 ReferenceType, TypeDescType>(eleTy))
     return emitError() << "cannot build a reference to type: " << eleTy << '\n';