[flang][openacc] Add OpenACC pointer interface to FIR pointer types

[razvanlupusoru]

Summary

The OpenACC dialect data clauses require for variables appearing in data
operations to implement the PointerLikeType interface (similarly to
OpenMP dialect). Thus, this interface needs attached to FIR types.

Two of the FIR types, HeapType and LLVMPointerType, did not provide
getElementType - now they do by calling getEleTy. This cleans up the
interface attachment for both OpenACC and OpenMP dialects.

[clementval]

LGTM

[razvanlupusoru]

Rebased

[razvanlupusoru]

Rebased again now that its parent has landed:
https://reviews.llvm.org/D148389
Will wait for build status to be green before landing this one.

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

def fir_HeapType : FIR_Type<"Heap", "heap"> {
   let skipDefaultBuilders = 1;
 
   let builders = [
     TypeBuilderWithInferredContext<(ins "mlir::Type":$elementType), [{
       assert(singleIndirectionLevel(elementType) && "invalid element type");
       return Base::get(elementType.getContext(), elementType);
     }]>,
   ];
+
+  let extraClassDeclaration = [{
+    mlir::Type getElementType() const { return getEleTy(); }
+  }];
 }
 
 def fir_IntegerType : FIR_Type<"Integer", "int"> {
   let summary = "FIR integer type";
 
   let description = [{
     Model of a Fortran INTEGER intrinsic type, including the KIND type
     parameter.
def fir_LLVMPointerType : FIR_Type<"LLVMPointer", "llvm_ptr"> {
 
   let assemblyFormat = "`<` $eleTy `>`";
 
   let builders = [
     TypeBuilderWithInferredContext<(ins "mlir::Type":$elementType), [{
       return Base::get(elementType.getContext(), elementType);
     }]>,
   ];
+
+  let extraClassDeclaration = [{
+    mlir::Type getElementType() const { return getEleTy(); }
+  }];
 }
 
 def fir_PointerType : FIR_Type<"Pointer", "ptr"> {
   let summary = "Reference to a POINTER attribute type";
 
   let description = [{
     The type of entities with the POINTER attribute.  These pointers are
     explicitly distinguished to disallow the composition of multiple levels of

flang/include/flang/Tools/PointerModels.h

 //===-- Tools/PointerModels.h --------------------- *-C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_TOOLS_POINTER_MODELS_H
 #define FORTRAN_TOOLS_POINTER_MODELS_H
 
+#include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 
-/// models for FIR pointer like types that already provide a `getElementType` or
-/// a `getEleTy` method
+/// models for FIR pointer like types that already provide a `getElementType`
+/// method
 
 template <typename T>
-struct PointerLikeModel
-    : public mlir::omp::PointerLikeType::ExternalModel<PointerLikeModel<T>, T> {
+struct OpenMPPointerLikeModel
+    : public mlir::omp::PointerLikeType::ExternalModel<
+          OpenMPPointerLikeModel<T>, T> {
   mlir::Type getElementType(mlir::Type pointer) const {
     return pointer.cast<T>().getElementType();
   }
 };
 
 template <typename T>
-struct AlternativePointerLikeModel
-    : public mlir::omp::PointerLikeType::ExternalModel<
-          AlternativePointerLikeModel<T>, T> {
+struct OpenACCPointerLikeModel
+    : public mlir::acc::PointerLikeType::ExternalModel<
+          OpenACCPointerLikeModel<T>, T> {
   mlir::Type getElementType(mlir::Type pointer) const {
-    return pointer.cast<T>().getEleTy();
+    return pointer.cast<T>().getElementType();
   }
 };
 
 #endif // FORTRAN_TOOLS_POINTER_MODELS_H

flang/lib/Optimizer/Dialect/FIRType.cpp

 //===-- FIRType.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 //===----------------------------------------------------------------------===//
 
 void FIROpsDialect::registerTypes() {
   addTypes<BoxType, BoxCharType, BoxProcType, CharacterType, ClassType,
            fir::ComplexType, FieldType, HeapType, fir::IntegerType, LenType,
            LogicalType, LLVMPointerType, PointerType, RealType, RecordType,
            ReferenceType, SequenceType, ShapeType, ShapeShiftType, ShiftType,
            SliceType, TypeDescType, fir::VectorType>();
-  fir::ReferenceType::attachInterface<PointerLikeModel<fir::ReferenceType>>(
-      *getContext());
+  fir::ReferenceType::attachInterface<
+      OpenMPPointerLikeModel<fir::ReferenceType>>(*getContext());
+  fir::ReferenceType::attachInterface<
+      OpenACCPointerLikeModel<fir::ReferenceType>>(*getContext());
 
-  fir::PointerType::attachInterface<PointerLikeModel<fir::PointerType>>(
+  fir::PointerType::attachInterface<OpenMPPointerLikeModel<fir::PointerType>>(
+      *getContext());
+  fir::PointerType::attachInterface<OpenACCPointerLikeModel<fir::PointerType>>(
       *getContext());
 
-  fir::HeapType::attachInterface<AlternativePointerLikeModel<fir::HeapType>>(
+  fir::HeapType::attachInterface<OpenMPPointerLikeModel<fir::HeapType>>(
+      *getContext());
+  fir::HeapType::attachInterface<OpenACCPointerLikeModel<fir::HeapType>>(
       *getContext());
 
   fir::LLVMPointerType::attachInterface<
-      AlternativePointerLikeModel<fir::LLVMPointerType>>(*getContext());
+      OpenMPPointerLikeModel<fir::LLVMPointerType>>(*getContext());
+  fir::LLVMPointerType::attachInterface<
+      OpenACCPointerLikeModel<fir::LLVMPointerType>>(*getContext());
 }