address comments on renaming

Author: RiverDave

clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h

@@ -121,7 +121,7 @@ class CIRBaseBuilderTy : public mlir::OpBuilder {
       return getPointerTo(ty);
 
     mlir::ptr::MemorySpaceAttrInterface addrSpaceAttr =
-        cir::toCIRLanguageAddressSpaceAttr(getContext(), langAS);
+        cir::toCIRLangAddressSpaceAttr(getContext(), langAS);
     return getPointerTo(ty, addrSpaceAttr);
   }
 

clang/include/clang/CIR/Dialect/IR/CIRAttrs.td

@@ -964,36 +964,37 @@ def CIR_DynamicCastInfoAttr : CIR_Attr<"DynamicCastInfo", "dyn_cast_info"> {
 // AddressSpaceAttr
 //===----------------------------------------------------------------------===//
 
-def CIR_LanguageAddressSpaceAttr :  CIR_EnumAttr<CIR_LanguageAddressSpace, "language_address_space", [
+def CIR_LangAddressSpaceAttr :
+              CIR_EnumAttr<CIR_LangAddressSpace, "lang_address_space", [
     DeclareAttrInterfaceMethods<MemorySpaceAttrInterface>
   ]> {
 
   let summary = "Represents a language address space";
   let description = [{
     Encodes the semantic address spaces defined by the front-end language
     (e.g. `__shared__`, `__constant__`, `__local__`). Values are stored using the
-    `cir::LanguageAddressSpace` enum, keeping the representation compact while and
+    `cir::LangAddressSpace` enum, keeping the representation compact while and
      preserves the qualifier until it is mapped onto target/LLVM address-space numbers.
 
      Example: 
      ``` mlir
-     !cir.ptr<!s32i, language_address_space(offload_local)>
-     cir.global constant external language_address_space(offload_constant)
+     !cir.ptr<!s32i, lang_address_space(offload_local)>
+     cir.global constant external lang_address_space(offload_constant)
 
      ```
   }];
 
   let builders = [
     AttrBuilder<(ins "clang::LangAS":$langAS), [{
-      return $_get($_ctxt, cir::toCIRLanguageAddressSpace(langAS));
+      return $_get($_ctxt, cir::toCIRLangAddressSpace(langAS));
     }]>
   ];
 
   let assemblyFormat = [{
     `(` custom<AddressSpaceValue>($value) `)`
   }];
 
-  let defaultValue = "cir::LanguageAddressSpace::Default";
+  let defaultValue = "cir::LangAddressSpace::Default";
 
   let extraClassDeclaration = [{
     unsigned getAsUnsignedValue() const;

clang/include/clang/CIR/Dialect/IR/CIREnumAttr.td

@@ -41,8 +41,8 @@ class CIR_DefaultValuedEnumParameter<EnumAttrInfo info, string value = "">
   let defaultValue = value;
 }
 
-def CIR_LanguageAddressSpace : CIR_I32EnumAttr<
-  "LanguageAddressSpace", "language address space kind", [
+def CIR_LangAddressSpace : CIR_I32EnumAttr<
+  "LangAddressSpace", "language address space kind", [
   I32EnumAttrCase<"Default", 0, "default">,
   I32EnumAttrCase<"OffloadPrivate", 1, "offload_private">,
   I32EnumAttrCase<"OffloadLocal", 2, "offload_local">,
@@ -57,7 +57,7 @@ def CIR_LanguageAddressSpace : CIR_I32EnumAttr<
 
     The `value` parameter is an extensible enum, which encodes target address
     space as an offset to the last language address space. For that reason, the
-    attribute is implemented as custom LanguageAddressSpaceAttr, which provides custom
+    attribute is implemented as custom LangAddressSpaceAttr, which provides custom
     printer and parser for the `value` parameter.
   }];
 

clang/include/clang/CIR/Dialect/IR/CIRTypes.h

@@ -35,17 +35,17 @@ bool isSized(mlir::Type ty);
 // AddressSpace helpers
 //===----------------------------------------------------------------------===//
 
-cir::LanguageAddressSpace toCIRLanguageAddressSpace(clang::LangAS langAS);
+cir::LangAddressSpace toCIRLangAddressSpace(clang::LangAS langAS);
 
 /// Convert a LangAS to the appropriate address space attribute interface.
 /// Returns a MemorySpaceAttrInterface.
 mlir::ptr::MemorySpaceAttrInterface
-toCIRLanguageAddressSpaceAttr(mlir::MLIRContext *ctx, clang::LangAS langAS);
+toCIRLangAddressSpaceAttr(mlir::MLIRContext *ctx, clang::LangAS langAS);
 
 bool isSupportedCIRMemorySpaceAttr(
     mlir::ptr::MemorySpaceAttrInterface memorySpace);
 
-constexpr unsigned getAsUnsignedValue(cir::LanguageAddressSpace as) {
+constexpr unsigned getAsUnsignedValue(cir::LangAddressSpace as) {
   return static_cast<unsigned>(as);
 }
 

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -1730,7 +1730,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     // builtin / dynamic alloca we have to handle it here.
     assert(!cir::MissingFeatures::addressSpace());
     mlir::ptr::MemorySpaceAttrInterface AAS = getCIRAllocaAddressSpace();
-    mlir::ptr::MemorySpaceAttrInterface EAS = cir::toCIRLanguageAddressSpaceAttr(
+    mlir::ptr::MemorySpaceAttrInterface EAS = cir::toCIRLangAddressSpaceAttr(
         &getMLIRContext(), E->getType()->getPointeeType().getAddressSpace());
     if (EAS != AAS) {
       assert(false && "Non-default address space for alloca NYI");

clang/lib/CIR/CodeGen/CIRGenDecl.cpp

@@ -481,7 +481,7 @@ CIRGenModule::getOrCreateStaticVarDecl(const VarDecl &D,
     Name = getStaticDeclName(*this, D);
 
   mlir::Type LTy = getTypes().convertTypeForMem(Ty);
-  mlir::ptr::MemorySpaceAttrInterface AS = cir::toCIRLanguageAddressSpaceAttr(
+  mlir::ptr::MemorySpaceAttrInterface AS = cir::toCIRLangAddressSpaceAttr(
       &getMLIRContext(), getGlobalVarAddressSpace(&D));
 
   // OpenCL variables in local address space and CUDA shared

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -2081,9 +2081,9 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *E) {
   case CK_AddressSpaceConversion: {
     LValue LV = emitLValue(E->getSubExpr());
     QualType DestTy = getContext().getPointerType(E->getType());
-    mlir::Attribute SrcAS = cir::toCIRLanguageAddressSpaceAttr(
+    mlir::Attribute SrcAS = cir::toCIRLangAddressSpaceAttr(
         &getMLIRContext(), E->getSubExpr()->getType().getAddressSpace());
-    mlir::Attribute DestAS = cir::toCIRLanguageAddressSpaceAttr(
+    mlir::Attribute DestAS = cir::toCIRLangAddressSpaceAttr(
         &getMLIRContext(), E->getType().getAddressSpace());
     mlir::Value V = getTargetHooks().performAddrSpaceCast(
         *this, LV.getPointer(), SrcAS, DestAS, convertType(DestTy));
@@ -3138,7 +3138,7 @@ Address CIRGenFunction::CreateTempAlloca(mlir::Type Ty, CharUnits Align,
   // be different from the type defined by the language. For example,
   // in C++ the auto variables are in the default address space. Therefore
   // cast alloca to the default address space when necessary.
-  if (auto ASTAS = cir::toCIRLanguageAddressSpaceAttr(
+  if (auto ASTAS = cir::toCIRLangAddressSpaceAttr(
           &getMLIRContext(), CGM.getLangTempAllocaAddressSpace());
       getCIRAllocaAddressSpace() != ASTAS) {
     llvm_unreachable("Requires address space cast which is NYI");

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -1690,10 +1690,10 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
     }
     // Since target may map different address spaces in AST to the same address
     // space, an address space conversion may end up as a bitcast.
-    mlir::Attribute SrcAS = cir::toCIRLanguageAddressSpaceAttr(
+    mlir::Attribute SrcAS = cir::toCIRLangAddressSpaceAttr(
         &CGF.getMLIRContext(),
         E->getType()->getPointeeType().getAddressSpace());
-    mlir::Attribute DestAS = cir::toCIRLanguageAddressSpaceAttr(
+    mlir::Attribute DestAS = cir::toCIRLangAddressSpaceAttr(
         &CGF.getMLIRContext(), DestTy->getPointeeType().getAddressSpace());
 
     return CGF.CGM.getTargetCIRGenInfo().performAddrSpaceCast(

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -1112,7 +1112,7 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty,
   }
 
   mlir::Attribute cirAS =
-      cir::toCIRLanguageAddressSpaceAttr(&getMLIRContext(), langAS);
+      cir::toCIRLangAddressSpaceAttr(&getMLIRContext(), langAS);
   if (entry) {
     mlir::ptr::MemorySpaceAttrInterface entryCIRAS = entry.getAddrSpaceAttr();
     if (WeakRefReferences.erase(entry)) {
@@ -1169,7 +1169,7 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty,
   }
 
   mlir::ptr::MemorySpaceAttrInterface declCIRAS =
-      cir::toCIRLanguageAddressSpaceAttr(&getMLIRContext(),
+      cir::toCIRLangAddressSpaceAttr(&getMLIRContext(),
                                       getGlobalVarAddressSpace(d));
   // TODO(cir): do we need to strip pointer casts for Entry?
 
@@ -1776,7 +1776,7 @@ generateStringLiteral(mlir::Location loc, mlir::TypedAttr c,
                       cir::GlobalLinkageKind lt, CIRGenModule &cgm,
                       StringRef globalName, CharUnits alignment) {
   mlir::ptr::MemorySpaceAttrInterface addrSpace =
-      cir::toCIRLanguageAddressSpaceAttr(&cgm.getMLIRContext(),
+      cir::toCIRLangAddressSpaceAttr(&cgm.getMLIRContext(),
                                       cgm.getGlobalConstantAddressSpace());
 
   // Create a global variable for this string
@@ -1991,7 +1991,7 @@ CIRGenModule::getAddrOfGlobalTemporary(const MaterializeTemporaryExpr *expr,
     }
   }
   mlir::ptr::MemorySpaceAttrInterface targetAS =
-      cir::toCIRLanguageAddressSpaceAttr(&getMLIRContext(), addrSpace);
+      cir::toCIRLangAddressSpaceAttr(&getMLIRContext(), addrSpace);
 
   auto loc = getLoc(expr->getSourceRange());
   auto gv = createGlobalOp(*this, loc, name, type, isConstant, targetAS,

clang/lib/CIR/CodeGen/TargetInfo.cpp

@@ -269,9 +269,9 @@ class CommonSPIRTargetCIRGenInfo : public TargetCIRGenInfo {
 
   mlir::ptr::MemorySpaceAttrInterface
   getCIRAllocaAddressSpace() const override {
-    return cir::LanguageAddressSpaceAttr::get(
+    return cir::LangAddressSpaceAttr::get(
         &getABIInfo().CGT.getMLIRContext(),
-        cir::LanguageAddressSpace::OffloadPrivate);
+        cir::LangAddressSpace::OffloadPrivate);
   }
 
   cir::CallingConv getOpenCLKernelCallingConv() const override {