[AST] Fix typo in MicrosoftMangle

[smeenai]

Summary

I noticed that we were spelling it as Artifical instead of Artificial
when working on the mangling for Obj-C RTTI. I'm putting this up for
review instead of committing it directly because I'm not 100% sure what
the policy here would be; it does clutter up the blame, but at the same
time it's fixing a gotcha for people writing new code.

[rnk]

I'd say feel free to commit typo fixes like this in the future. I'd avoid fixing typos where there is spelling disagreement, like "prolog vs prologue", so just use your best judgement as always.
lgtm

lib/AST/MicrosoftMangle.cpp

public:
   void mangleVariableEncoding(const VarDecl *VD);
   void mangleMemberDataPointer(const CXXRecordDecl *RD, const ValueDecl *VD);
   void mangleMemberFunctionPointer(const CXXRecordDecl *RD,
                                    const CXXMethodDecl *MD);
   void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
                                 const MethodVFTableLocation &ML);
   void mangleNumber(int64_t Number);
   void mangleTagTypeKind(TagTypeKind TK);
-  void mangleArtificalTagType(TagTypeKind TK, StringRef UnqualifiedName,
+  void mangleArtificialTagType(TagTypeKind TK, StringRef UnqualifiedName,
                               ArrayRef<StringRef> NestedNames = None);
   void mangleType(QualType T, SourceRange Range,
                   QualifierMangleMode QMM = QMM_Mangle);
   void mangleFunctionType(const FunctionType *T,
                           const FunctionDecl *D = nullptr,
                           bool ForceThisQuals = false);
   void mangleNestedName(const NamedDecl *ND);
 
if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) {
       // void __cdecl
       Out << "YAX";
       // struct __block_literal *
       Out << 'P';
       // __ptr64
       if (PointersAre64Bit)
         Out << 'E';
       Out << 'A';
-      mangleArtificalTagType(TTK_Struct,
+      mangleArtificialTagType(TTK_Struct,
                              Discriminate("__block_literal", Discriminator,
                                           ParameterDiscriminator));
       Out << "@Z";
 
       // If the effective context was a Record, we have fully mangled the
       // qualified name and do not need to continue.
       if (isa<RecordDecl>(DC))
         break;
if (UE) {
     std::replace(Name.begin(), Name.end(), '-', '_');
 
     mangleSourceName(Name);
     // Terminate the whole name with an '@'.
     Out << '@';
     // It's a global variable.
     Out << '3';
     // It's a struct called __s_GUID.
-    mangleArtificalTagType(TTK_Struct, "__s_GUID");
+    mangleArtificialTagType(TTK_Struct, "__s_GUID");
     // It's const.
     Out << 'B';
     return;
   }
 
   // As bad as this diagnostic is, it's better than crashing.
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(

 
 void MicrosoftCXXNameMangler::mangleObjCProtocol(const ObjCProtocolDecl *PD) {
   llvm::SmallString<64> TemplateMangling;
   llvm::raw_svector_ostream Stream(TemplateMangling);
   MicrosoftCXXNameMangler Extra(Context, Stream);
 
   Stream << "?$";
   Extra.mangleSourceName("Protocol");
-  Extra.mangleArtificalTagType(TTK_Struct, PD->getName());
+  Extra.mangleArtificialTagType(TTK_Struct, PD->getName());
 
-  mangleArtificalTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
+  mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
 }
 
 void MicrosoftCXXNameMangler::mangleObjCLifetime(const QualType Type,
                                                  Qualifiers Quals,
                                                  SourceRange Range) {
   llvm::SmallString<64> TemplateMangling;
   llvm::raw_svector_ostream Stream(TemplateMangling);
   MicrosoftCXXNameMangler Extra(Context, Stream);
void MicrosoftCXXNameMangler::mangleObjCLifetime(const QualType Type,
   case Qualifiers::OCL_Weak:
     Extra.mangleSourceName("Weak");
     break;
   }
   Extra.manglePointerCVQualifiers(Quals);
   Extra.manglePointerExtQualifiers(Quals, Type);
   Extra.mangleType(Type, Range);
 
-  mangleArtificalTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
+  mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
 }
 
 void MicrosoftCXXNameMangler::mangleObjCKindOfType(const ObjCObjectType *T,
                                                    Qualifiers Quals,
                                                    SourceRange Range) {
   llvm::SmallString<64> TemplateMangling;
   llvm::raw_svector_ostream Stream(TemplateMangling);
   MicrosoftCXXNameMangler Extra(Context, Stream);
 
   Stream << "?$";
   Extra.mangleSourceName("KindOf");
   Extra.mangleType(QualType(T, 0)
                        .stripObjCKindOfType(getASTContext())
                        ->getAs<ObjCObjectType>(),
                    Quals, Range);
 
-  mangleArtificalTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
+  mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
 }
 
 void MicrosoftCXXNameMangler::mangleQualifiers(Qualifiers Quals,
                                                bool IsMember) {
   // <cvr-qualifiers> ::= [E] [F] [I] <base-cvr-qualifiers>
   // 'E' means __ptr64 (32-bit only); 'F' means __unaligned (32/64-bit only);
   // 'I' means __restrict (32/64-bit).
   // Note that the MSVC __restrict keyword isn't the same as the C99 restrict
void MicrosoftCXXNameMangler::manglePassObjectSizeArg(
     const PassObjectSizeAttr *POSA) {
   int Type = POSA->getType();
 
   auto Iter = PassObjectSizeArgs.insert(Type).first;
   auto *TypePtr = (const void *)&*Iter;
   ArgBackRefMap::iterator Found = TypeBackReferences.find(TypePtr);
 
   if (Found == TypeBackReferences.end()) {
-    mangleArtificalTagType(TTK_Enum, "__pass_object_size" + llvm::utostr(Type),
+    mangleArtificialTagType(TTK_Enum, "__pass_object_size" + llvm::utostr(Type),
                            {"__clang"});
 
     if (TypeBackReferences.size() < 10) {
       size_t Size = TypeBackReferences.size();
       TypeBackReferences[TypePtr] = Size;
     }
   } else {
     Out << Found->second;

 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
   case BuiltinType::Dependent:
     llvm_unreachable("placeholder types shouldn't get to name mangling");
 
   case BuiltinType::ObjCId:
-    mangleArtificalTagType(TTK_Struct, "objc_object");
+    mangleArtificialTagType(TTK_Struct, "objc_object");
     break;
   case BuiltinType::ObjCClass:
-    mangleArtificalTagType(TTK_Struct, "objc_class");
+    mangleArtificialTagType(TTK_Struct, "objc_class");
     break;
   case BuiltinType::ObjCSel:
-    mangleArtificalTagType(TTK_Struct, "objc_selector");
+    mangleArtificialTagType(TTK_Struct, "objc_selector");
     break;
 
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   case BuiltinType::Id: \
     Out << "PAUocl_" #ImgType "_" #Suffix "@@"; \
     break;
 #include "clang/Basic/OpenCLImageTypes.def"
   case BuiltinType::OCLSampler:
     Out << "PA";
-    mangleArtificalTagType(TTK_Struct, "ocl_sampler");
+    mangleArtificialTagType(TTK_Struct, "ocl_sampler");
     break;
   case BuiltinType::OCLEvent:
     Out << "PA";
-    mangleArtificalTagType(TTK_Struct, "ocl_event");
+    mangleArtificialTagType(TTK_Struct, "ocl_event");
     break;
   case BuiltinType::OCLClkEvent:
     Out << "PA";
-    mangleArtificalTagType(TTK_Struct, "ocl_clkevent");
+    mangleArtificialTagType(TTK_Struct, "ocl_clkevent");
     break;
   case BuiltinType::OCLQueue:
     Out << "PA";
-    mangleArtificalTagType(TTK_Struct, "ocl_queue");
+    mangleArtificialTagType(TTK_Struct, "ocl_queue");
     break;
   case BuiltinType::OCLReserveID:
     Out << "PA";
-    mangleArtificalTagType(TTK_Struct, "ocl_reserveid");
+    mangleArtificialTagType(TTK_Struct, "ocl_reserveid");
     break;
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
   case BuiltinType::Id: \
-    mangleArtificalTagType(TTK_Struct, "ocl_" #ExtType); \
+    mangleArtificialTagType(TTK_Struct, "ocl_" #ExtType); \
     break;
 #include "clang/Basic/OpenCLExtensionTypes.def"
 
   case BuiltinType::NullPtr:
     Out << "$$T";
     break;
 
   case BuiltinType::Float16:
-    mangleArtificalTagType(TTK_Struct, "_Float16", {"__clang"});
+    mangleArtificialTagType(TTK_Struct, "_Float16", {"__clang"});
     break;
 
   case BuiltinType::Half:
-    mangleArtificalTagType(TTK_Struct, "_Half", {"__clang"});
+    mangleArtificialTagType(TTK_Struct, "_Half", {"__clang"});
     break;
 
   case BuiltinType::ShortAccum:
   case BuiltinType::Accum:
   case BuiltinType::LongAccum:
   case BuiltinType::UShortAccum:
   case BuiltinType::UAccum:
   case BuiltinType::ULongAccum:
void MicrosoftCXXNameMangler::mangleType(const RecordType *T, Qualifiers,
   mangleType(cast<TagType>(T)->getDecl());
 }
 void MicrosoftCXXNameMangler::mangleType(const TagDecl *TD) {
   mangleTagTypeKind(TD->getTagKind());
   mangleName(TD);
 }
 
 // If you add a call to this, consider updating isArtificialTagType() too.
-void MicrosoftCXXNameMangler::mangleArtificalTagType(
+void MicrosoftCXXNameMangler::mangleArtificialTagType(
     TagTypeKind TK, StringRef UnqualifiedName,
     ArrayRef<StringRef> NestedNames) {
   // <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @
   mangleTagTypeKind(TK);
 
   // Always start with the unqualified name.
   mangleSourceName(UnqualifiedName);
 
void MicrosoftCXXNameMangler::mangleType(const ComplexType *T, Qualifiers,
 
   llvm::SmallString<64> TemplateMangling;
   llvm::raw_svector_ostream Stream(TemplateMangling);
   MicrosoftCXXNameMangler Extra(Context, Stream);
   Stream << "?$";
   Extra.mangleSourceName("_Complex");
   Extra.mangleType(ElementType, Range, QMM_Escape);
 
-  mangleArtificalTagType(TTK_Struct, TemplateMangling, {"__clang"});
+  mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
 }
 
-// Returns true for types that mangleArtificalTagType() gets called for with
+// Returns true for types that mangleArtificialTagType() gets called for with
 // TTK_Union, TTK_Struct, TTK_Class and where compatibility with MSVC's
 // mangling matters.
 // (It doesn't matter for Objective-C types and the like that cl.exe doesn't
 // support.)
 bool MicrosoftCXXNameMangler::isArtificialTagType(QualType T) const {
   const Type *ty = T.getTypePtr();
   switch (ty->getTypeClass()) {
   default:
     return false;
 
   case Type::Vector: {
     // For ABI compatibility only __m64, __m128(id), and __m256(id) matter,
-    // but since mangleType(VectorType*) always calls mangleArtificalTagType()
+    // but since mangleType(VectorType*) always calls mangleArtificialTagType()
     // just always return true (the other vector types are clang-only).
     return true;
   }
   }
 }
 
 void MicrosoftCXXNameMangler::mangleType(const VectorType *T, Qualifiers Quals,
                                          SourceRange Range) {
   const BuiltinType *ET = T->getElementType()->getAs<BuiltinType>();
   assert(ET && "vectors with non-builtin elements are unsupported");
   uint64_t Width = getASTContext().getTypeSize(T);
   // Pattern match exactly the typedefs in our intrinsic headers.  Anything that
   // doesn't match the Intel types uses a custom mangling below.
   size_t OutSizeBefore = Out.tell();
   if (!isa<ExtVectorType>(T)) {
     llvm::Triple::ArchType AT =
         getASTContext().getTargetInfo().getTriple().getArch();
     if (AT == llvm::Triple::x86 || AT == llvm::Triple::x86_64) {
       if (Width == 64 && ET->getKind() == BuiltinType::LongLong) {
-        mangleArtificalTagType(TTK_Union, "__m64");
+        mangleArtificialTagType(TTK_Union, "__m64");
       } else if (Width >= 128) {
         if (ET->getKind() == BuiltinType::Float)
-          mangleArtificalTagType(TTK_Union, "__m" + llvm::utostr(Width));
+          mangleArtificialTagType(TTK_Union, "__m" + llvm::utostr(Width));
         else if (ET->getKind() == BuiltinType::LongLong)
-          mangleArtificalTagType(TTK_Union, "__m" + llvm::utostr(Width) + 'i');
+          mangleArtificialTagType(TTK_Union, "__m" + llvm::utostr(Width) + 'i');
         else if (ET->getKind() == BuiltinType::Double)
-          mangleArtificalTagType(TTK_Struct, "__m" + llvm::utostr(Width) + 'd');
+          mangleArtificialTagType(TTK_Struct, "__m" + llvm::utostr(Width) + 'd');
       }
     }
   }
 
   bool IsBuiltin = Out.tell() != OutSizeBefore;
   if (!IsBuiltin) {
     // The MS ABI doesn't have a special mangling for vector types, so we define
     // our own mangling to handle uses of __vector_size__ on user-specified
     // types, and for extensions like __v4sf.
 
     llvm::SmallString<64> TemplateMangling;
     llvm::raw_svector_ostream Stream(TemplateMangling);
     MicrosoftCXXNameMangler Extra(Context, Stream);
     Stream << "?$";
     Extra.mangleSourceName("__vector");
     Extra.mangleType(QualType(ET, 0), Range, QMM_Escape);
     Extra.mangleIntegerLiteral(llvm::APSInt::getUnsigned(T->getNumElements()),
                                /*IsBoolean=*/false);
 
-    mangleArtificalTagType(TTK_Union, TemplateMangling, {"__clang"});
+    mangleArtificialTagType(TTK_Union, TemplateMangling, {"__clang"});
   }
 }
 
 void MicrosoftCXXNameMangler::mangleType(const ExtVectorType *T,
                                          Qualifiers Quals, SourceRange Range) {
   mangleType(static_cast<const VectorType *>(T), Quals, Range);
 }
 
void MicrosoftCXXNameMangler::mangleType(const AtomicType *T, Qualifiers,
 
   llvm::SmallString<64> TemplateMangling;
   llvm::raw_svector_ostream Stream(TemplateMangling);
   MicrosoftCXXNameMangler Extra(Context, Stream);
   Stream << "?$";
   Extra.mangleSourceName("_Atomic");
   Extra.mangleType(ValueType, Range, QMM_Escape);
 
-  mangleArtificalTagType(TTK_Struct, TemplateMangling, {"__clang"});
+  mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
 }
 
 void MicrosoftCXXNameMangler::mangleType(const PipeType *T, Qualifiers,
                                          SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
     "cannot mangle this OpenCL pipe type yet");
   Diags.Report(Range.getBegin(), DiagID)