IR: Stop using DIDescriptor::is*() and auto-casting

`DIDescriptor`'s subclasses allow construction from incompatible
pointers, and `DIDescriptor` defines a series of `isa<>`-like functions
(e.g., `isCompileUnit()` instead of `isa<MDCompileUnit>()`) that clients
tend to use like this:

    if (DICompileUnit(N).isCompileUnit())
      foo(DICompileUnit(N));

These construction patterns work together to make `DIDescriptor` behave
differently from normal pointers.

Instead, use built-in `isa<>`, `dyn_cast<>`, etc., and only build
`DIDescriptor`s from pointers that are valid for their type.

I've split this into a few commits for different parts of LLVM and clang
(to decrease the patch size and increase the chance of review).
Generally the changes I made were NFC, but in a few places I made things
stricter if it made sense from the surrounded code.

Eventually a follow-up commit will remove the API for the "old" way.

llvm-svn: 234255

3 files changed, 107 insertions, 130 deletions

diff --git a/llvm/lib/IR/DIBuilder.cpp b/llvm/lib/IR/DIBuilder.cpp
index 35e0ffc8c0d..662b1dfe261 100644
--- a/llvm/lib/IR/DIBuilder.cpp
+++ b/llvm/lib/IR/DIBuilder.cpp
@@ -75,7 +75,7 @@ void DIBuilder::trackIfUnresolved(MDNode *N) {
 
 void DIBuilder::finalize() {
   DIArray Enums = getOrCreateArray(AllEnumTypes);
-  DIType(TempEnumTypes).replaceAllUsesWith(Enums);
+  TempEnumTypes->replaceAllUsesWith(Enums);
 
   SmallVector<Metadata *, 16> RetainValues;
   // Declarations and definitions of the same type may be retained. Some
@@ -87,27 +87,27 @@ void DIBuilder::finalize() {
     if (RetainSet.insert(AllRetainTypes[I]).second)
       RetainValues.push_back(AllRetainTypes[I]);
   DIArray RetainTypes = getOrCreateArray(RetainValues);
-  DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes);
+  TempRetainTypes->replaceAllUsesWith(RetainTypes);
 
   DIArray SPs = getOrCreateArray(AllSubprograms);
-  DIType(TempSubprograms).replaceAllUsesWith(SPs);
+  TempSubprograms->replaceAllUsesWith(SPs);
   for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
-    DISubprogram SP(SPs.getElement(i));
+    DISubprogram SP = cast<MDSubprogram>(SPs.getElement(i));
     if (MDNode *Temp = SP.getVariablesNodes()) {
       const auto &PV = PreservedVariables.lookup(SP);
       SmallVector<Metadata *, 4> Variables(PV.begin(), PV.end());
       DIArray AV = getOrCreateArray(Variables);
-      DIType(Temp).replaceAllUsesWith(AV);
+      Temp->replaceAllUsesWith(AV);
     }
   }
 
   DIArray GVs = getOrCreateArray(AllGVs);
-  DIType(TempGVs).replaceAllUsesWith(GVs);
+  TempGVs->replaceAllUsesWith(GVs);
 
   SmallVector<Metadata *, 16> RetainValuesI(AllImportedModules.begin(),
                                             AllImportedModules.end());
   DIArray IMs = getOrCreateArray(RetainValuesI);
-  DIType(TempImportedModules).replaceAllUsesWith(IMs);
+  TempImportedModules->replaceAllUsesWith(IMs);
 
   // Now that all temp nodes have been replaced or deleted, resolve remaining
   // cycles.
@@ -151,7 +151,7 @@ DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
 
   // TODO: Switch to getDistinct().  We never want to merge compile units based
   // on contents.
-  MDNode *CUNode = MDCompileUnit::get(
+  MDCompileUnit *CUNode = MDCompileUnit::get(
       VMContext, Lang, MDFile::get(VMContext, Filename, Directory), Producer,
       isOptimized, Flags, RunTimeVer, SplitName, Kind, TempEnumTypes,
       TempRetainTypes, TempSubprograms, TempGVs, TempImportedModules);
@@ -167,7 +167,7 @@ DICompileUnit DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
   }
 
   trackIfUnresolved(CUNode);
-  return DICompileUnit(CUNode);
+  return CUNode;
 }
 
 static DIImportedEntity
@@ -261,7 +261,7 @@ DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base,
 }
 
 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
-  assert(RTy.isType() && "Unable to create reference type");
+  assert(RTy && "Unable to create reference type");
   return MDDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
                             MDTypeRef::get(RTy), 0, 0, 0, 0);
 }
@@ -276,8 +276,8 @@ DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
 
 DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
   // typedefs are encoded in DIDerivedType format.
-  assert(Ty.isType() && "Invalid type!");
-  assert(FriendTy.isType() && "Invalid friend type!");
+  assert(Ty && "Invalid type!");
+  assert(FriendTy && "Invalid friend type!");
   return MDDerivedType::get(VMContext, dwarf::DW_TAG_friend, "", nullptr, 0,
                             MDTypeRef::get(Ty), MDTypeRef::get(FriendTy), 0, 0,
                             0, 0);
@@ -286,7 +286,7 @@ DIDerivedType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
 DIDerivedType DIBuilder::createInheritance(DIType Ty, DIType BaseTy,
                                            uint64_t BaseOffset,
                                            unsigned Flags) {
-  assert(Ty.isType() && "Unable to create inheritance");
+  assert(Ty && "Unable to create inheritance");
   return MDDerivedType::get(VMContext, dwarf::DW_TAG_inheritance, "", nullptr,
                             0, MDTypeRef::get(Ty), MDTypeRef::get(BaseTy), 0, 0,
                             BaseOffset, Flags);
@@ -395,7 +395,7 @@ DICompositeType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
                                            DIType VTableHolder,
                                            MDNode *TemplateParams,
                                            StringRef UniqueIdentifier) {
-  assert((!Context || Context.isScope() || Context.isType()) &&
+  assert((!Context || isa<MDScope>(Context)) &&
          "createClassType should be called with a valid Context");
   // TAG_class_type is encoded in DICompositeType format.
   DICompositeType R = MDCompositeType::get(
@@ -564,7 +564,7 @@ DITypeArray DIBuilder::getOrCreateTypeArray(ArrayRef<Metadata *> Elements) {
   SmallVector<llvm::Metadata *, 16> Elts;
   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
     if (Elements[i] && isa<MDNode>(Elements[i]))
-      Elts.push_back(MDTypeRef::get(DIType(cast<MDNode>(Elements[i]))));
+      Elts.push_back(MDTypeRef::get(cast<MDType>(Elements[i])));
     else
       Elts.push_back(Elements[i]);
   }
@@ -576,11 +576,10 @@ DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
 }
 
 static void checkGlobalVariableScope(DIDescriptor Context) {
-  MDNode *TheCtx = getNonCompileUnitScope(Context);
-  if (DIScope(TheCtx).isCompositeType()) {
-    assert(!DICompositeType(TheCtx).getIdentifier() &&
+  if (DICompositeType CT =
+          dyn_cast_or_null<MDCompositeType>(getNonCompileUnitScope(Context)))
+    assert(!CT.getIdentifier() &&
            "Context of a global variable should not be a type with identifier");
-  }
 }
 
 DIGlobalVariable DIBuilder::createGlobalVariable(
@@ -618,9 +617,7 @@ DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
   // FIXME: Why is "!Context" okay here?
   // FIXME: WHy doesn't this check for a subprogram or lexical block (AFAICT
   // the only valid scopes)?
-  DIDescriptor Context(getNonCompileUnitScope(Scope));
-  assert((!Context || Context.isScope()) &&
-         "createLocalVariable should be called with a valid Context");
+  DIScope Context = getNonCompileUnitScope(Scope);
 
   auto *Node = MDLocalVariable::get(
       VMContext, Tag, cast_or_null<MDLocalScope>(Context.get()), Name, File,
@@ -723,19 +720,17 @@ DISubprogram DIBuilder::createMethod(DIDescriptor Context, StringRef Name,
          "Methods should have both a Context and a context that isn't "
          "the compile unit.");
   // FIXME: Do we want to use different scope/lines?
-  auto *Node = MDSubprogram::get(
-      VMContext, MDScopeRef::get(DIScope(Context)), Name, LinkageName, F.get(),
-      LineNo, cast_or_null<MDSubroutineType>(Ty.get()), isLocalToUnit,
+  auto *SP = MDSubprogram::get(
+      VMContext, MDScopeRef::get(cast<MDScope>(Context)), Name, LinkageName,
+      F.get(), LineNo, cast_or_null<MDSubroutineType>(Ty.get()), isLocalToUnit,
       isDefinition, LineNo, MDTypeRef::get(VTableHolder), VK, VIndex, Flags,
       isOptimized, getConstantOrNull(Fn), cast_or_null<MDTuple>(TParam),
       nullptr, nullptr);
 
   if (isDefinition)
-    AllSubprograms.push_back(Node);
-  DISubprogram S(Node);
-  assert(S.isSubprogram() && "createMethod should return a valid DISubprogram");
-  trackIfUnresolved(S);
-  return S;
+    AllSubprograms.push_back(SP);
+  trackIfUnresolved(SP);
+  return SP;
 }
 
 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
@@ -767,8 +762,7 @@ static Value *getDbgIntrinsicValueImpl(LLVMContext &VMContext, Value *V) {
 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
                                       DIExpression Expr,
                                       Instruction *InsertBefore) {
-  assert(VarInfo.isVariable() &&
-         "empty or invalid DIVariable passed to dbg.declare");
+  assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
   if (!DeclareFn)
     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 
@@ -783,8 +777,7 @@ Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
                                       DIExpression Expr,
                                       BasicBlock *InsertAtEnd) {
-  assert(VarInfo.isVariable() &&
-         "empty or invalid DIVariable passed to dbg.declare");
+  assert(VarInfo && "empty or invalid DIVariable passed to dbg.declare");
   if (!DeclareFn)
     DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
 
@@ -807,8 +800,7 @@ Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
                                                 DIExpression Expr,
                                                 Instruction *InsertBefore) {
   assert(V && "no value passed to dbg.value");
-  assert(VarInfo.isVariable() &&
-         "empty or invalid DIVariable passed to dbg.value");
+  assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
   if (!ValueFn)
     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 
@@ -826,8 +818,7 @@ Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
                                                 DIExpression Expr,
                                                 BasicBlock *InsertAtEnd) {
   assert(V && "no value passed to dbg.value");
-  assert(VarInfo.isVariable() &&
-         "empty or invalid DIVariable passed to dbg.value");
+  assert(VarInfo && "empty or invalid DIVariable passed to dbg.value");
   if (!ValueFn)
     ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
 
diff --git a/llvm/lib/IR/DebugInfo.cpp b/llvm/lib/IR/DebugInfo.cpp
index 721fbc8c3a0..b4364be9137 100644
--- a/llvm/lib/IR/DebugInfo.cpp
+++ b/llvm/lib/IR/DebugInfo.cpp
@@ -100,8 +100,8 @@ unsigned DIVariable::getSizeInBits(const DITypeIdentifierMap &Map) {
   DIType Ty = getType().resolve(Map);
   // Follow derived types until we reach a type that
   // reports back a size.
-  while (Ty.isDerivedType() && !Ty.getSizeInBits()) {
-    DIDerivedType DT(&*Ty);
+  while (isa<MDDerivedType>(Ty) && !Ty.getSizeInBits()) {
+    DIDerivedType DT = cast<MDDerivedType>(Ty);
     Ty = DT.getTypeDerivedFrom().resolve(Map);
   }
   assert(Ty.getSizeInBits() && "type with size 0");
@@ -207,11 +207,12 @@ void DICompositeType::setContainingType(DICompositeType ContainingType) {
 
 bool DIVariable::isInlinedFnArgument(const Function *CurFn) {
   assert(CurFn && "Invalid function");
-  if (!getContext().isSubprogram())
+  DISubprogram SP = dyn_cast<MDSubprogram>(getContext());
+  if (!SP)
     return false;
   // This variable is not inlined function argument if its scope
   // does not describe current function.
-  return !DISubprogram(getContext()).describes(CurFn);
+  return !SP.describes(CurFn);
 }
 
 Function *DISubprogram::getFunction() const {
@@ -238,35 +239,32 @@ GlobalVariable *DIGlobalVariable::getGlobal() const {
 }
 
 DIScopeRef DIScope::getContext() const {
+  if (DIType T = dyn_cast<MDType>(*this))
+    return T.getContext();
 
-  if (isType())
-    return DIType(DbgNode).getContext();
-
-  if (isSubprogram())
-    return DIScopeRef(DISubprogram(DbgNode).getContext());
+  if (DISubprogram SP = dyn_cast<MDSubprogram>(*this))
+    return DIScopeRef(SP.getContext());
 
-  if (isLexicalBlock())
-    return DIScopeRef(DILexicalBlock(DbgNode).getContext());
+  if (DILexicalBlock LB = dyn_cast<MDLexicalBlockBase>(*this))
+    return DIScopeRef(LB.getContext());
 
-  if (isLexicalBlockFile())
-    return DIScopeRef(DILexicalBlockFile(DbgNode).getContext());
+  if (DINameSpace NS = dyn_cast<MDNamespace>(*this))
+    return DIScopeRef(NS.getContext());
 
-  if (isNameSpace())
-    return DIScopeRef(DINameSpace(DbgNode).getContext());
-
-  assert((isFile() || isCompileUnit()) && "Unhandled type of scope.");
+  assert((isa<MDFile>(*this) || isa<MDCompileUnit>(*this)) &&
+         "Unhandled type of scope.");
   return DIScopeRef(nullptr);
 }
 
 StringRef DIScope::getName() const {
-  if (isType())
-    return DIType(DbgNode).getName();
-  if (isSubprogram())
-    return DISubprogram(DbgNode).getName();
-  if (isNameSpace())
-    return DINameSpace(DbgNode).getName();
-  assert((isLexicalBlock() || isLexicalBlockFile() || isFile() ||
-          isCompileUnit()) &&
+  if (DIType T = dyn_cast<MDType>(*this))
+    return T.getName();
+  if (DISubprogram SP = dyn_cast<MDSubprogram>(*this))
+    return SP.getName();
+  if (DINameSpace NS = dyn_cast<MDNamespace>(*this))
+    return NS.getName();
+  assert((isa<MDLexicalBlockBase>(*this) || isa<MDFile>(*this) ||
+          isa<MDCompileUnit>(*this)) &&
          "Unhandled type of scope.");
   return StringRef();
 }
@@ -341,31 +339,31 @@ DISubprogram llvm::getDISubprogram(const Function *F) {
 }
 
 DICompositeType llvm::getDICompositeType(DIType T) {
-  if (T.isCompositeType())
-    return DICompositeType(T);
+  if (auto *C = dyn_cast_or_null<MDCompositeTypeBase>(T))
+    return C;
 
-  if (T.isDerivedType()) {
+  if (auto *D = dyn_cast_or_null<MDDerivedTypeBase>(T)) {
     // This function is currently used by dragonegg and dragonegg does
     // not generate identifier for types, so using an empty map to resolve
     // DerivedFrom should be fine.
     DITypeIdentifierMap EmptyMap;
     return getDICompositeType(
-        DIDerivedType(T).getTypeDerivedFrom().resolve(EmptyMap));
+        DIDerivedType(D).getTypeDerivedFrom().resolve(EmptyMap));
   }
 
-  return DICompositeType();
+  return nullptr;
 }
 
 DITypeIdentifierMap
 llvm::generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes) {
   DITypeIdentifierMap Map;
   for (unsigned CUi = 0, CUe = CU_Nodes->getNumOperands(); CUi != CUe; ++CUi) {
-    DICompileUnit CU(CU_Nodes->getOperand(CUi));
+    DICompileUnit CU = cast<MDCompileUnit>(CU_Nodes->getOperand(CUi));
     DIArray Retain = CU.getRetainedTypes();
     for (unsigned Ti = 0, Te = Retain.getNumElements(); Ti != Te; ++Ti) {
-      if (!Retain.getElement(Ti).isCompositeType())
+      if (!isa<MDCompositeType>(Retain.getElement(Ti)))
         continue;
-      DICompositeType Ty(Retain.getElement(Ti));
+      DICompositeType Ty = cast<MDCompositeType>(Retain.getElement(Ti));
       if (MDString *TypeId = Ty.getIdentifier()) {
         // Definition has priority over declaration.
         // Try to insert (TypeId, Ty) to Map.
@@ -408,11 +406,11 @@ void DebugInfoFinder::processModule(const Module &M) {
   InitializeTypeMap(M);
   if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) {
     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
-      DICompileUnit CU(CU_Nodes->getOperand(i));
+      DICompileUnit CU = cast<MDCompileUnit>(CU_Nodes->getOperand(i));
       addCompileUnit(CU);
       DIArray GVs = CU.getGlobalVariables();
       for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) {
-        DIGlobalVariable DIG(GVs.getElement(i));
+        DIGlobalVariable DIG = cast<MDGlobalVariable>(GVs.getElement(i));
         if (addGlobalVariable(DIG)) {
           processScope(DIG.getContext());
           processType(DIG.getType().resolve(TypeIdentifierMap));
@@ -420,25 +418,23 @@ void DebugInfoFinder::processModule(const Module &M) {
       }
       DIArray SPs = CU.getSubprograms();
       for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
-        processSubprogram(DISubprogram(SPs.getElement(i)));
+        processSubprogram(cast<MDSubprogram>(SPs.getElement(i)));
       DIArray EnumTypes = CU.getEnumTypes();
       for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
-        processType(DIType(EnumTypes.getElement(i)));
+        processType(cast<MDType>(EnumTypes.getElement(i)));
       DIArray RetainedTypes = CU.getRetainedTypes();
       for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
-        processType(DIType(RetainedTypes.getElement(i)));
+        processType(cast<MDType>(RetainedTypes.getElement(i)));
       DIArray Imports = CU.getImportedEntities();
       for (unsigned i = 0, e = Imports.getNumElements(); i != e; ++i) {
-        DIImportedEntity Import = DIImportedEntity(Imports.getElement(i));
-        if (!Import)
-          continue;
+        DIImportedEntity Import = cast<MDImportedEntity>(Imports.getElement(i));
         DIDescriptor Entity = Import.getEntity().resolve(TypeIdentifierMap);
-        if (Entity.isType())
-          processType(DIType(Entity));
-        else if (Entity.isSubprogram())
-          processSubprogram(DISubprogram(Entity));
-        else if (Entity.isNameSpace())
-          processScope(DINameSpace(Entity).getContext());
+        if (auto *T = dyn_cast<MDType>(Entity))
+          processType(T);
+        else if (auto *SP = dyn_cast<MDSubprogram>(Entity))
+          processSubprogram(SP);
+        else if (auto *NS = dyn_cast<MDNamespace>(Entity))
+          processScope(NS->getScope());
       }
     }
   }
@@ -456,11 +452,10 @@ void DebugInfoFinder::processType(DIType DT) {
   if (!addType(DT))
     return;
   processScope(DT.getContext().resolve(TypeIdentifierMap));
-  if (DT.isCompositeType()) {
-    DICompositeType DCT(DT);
+  if (DICompositeType DCT = dyn_cast<MDCompositeTypeBase>(DT)) {
     processType(DCT.getTypeDerivedFrom().resolve(TypeIdentifierMap));
-    if (DT.isSubroutineType()) {
-      DITypeArray DTA = DISubroutineType(DT).getTypeArray();
+    if (DISubroutineType ST = dyn_cast<MDSubroutineType>(DCT)) {
+      DITypeArray DTA = ST.getTypeArray();
       for (unsigned i = 0, e = DTA.getNumElements(); i != e; ++i)
         processType(DTA.getElement(i).resolve(TypeIdentifierMap));
       return;
@@ -468,38 +463,36 @@ void DebugInfoFinder::processType(DIType DT) {
     DIArray DA = DCT.getElements();
     for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
       DIDescriptor D = DA.getElement(i);
-      if (D.isType())
-        processType(DIType(D));
-      else if (D.isSubprogram())
-        processSubprogram(DISubprogram(D));
+      if (DIType T = dyn_cast<MDType>(D))
+        processType(T);
+      else if (DISubprogram SP = dyn_cast<MDSubprogram>(D))
+        processSubprogram(SP);
     }
-  } else if (DT.isDerivedType()) {
-    DIDerivedType DDT(DT);
+  } else if (DIDerivedType DDT = dyn_cast<MDDerivedTypeBase>(DT)) {
     processType(DDT.getTypeDerivedFrom().resolve(TypeIdentifierMap));
   }
 }
 
 void DebugInfoFinder::processScope(DIScope Scope) {
-  if (Scope.isType()) {
-    DIType Ty(Scope);
+  if (!Scope)
+    return;
+  if (DIType Ty = dyn_cast<MDType>(Scope)) {
     processType(Ty);
     return;
   }
-  if (Scope.isCompileUnit()) {
-    addCompileUnit(DICompileUnit(Scope));
+  if (DICompileUnit CU = dyn_cast<MDCompileUnit>(Scope)) {
+    addCompileUnit(CU);
     return;
   }
-  if (Scope.isSubprogram()) {
-    processSubprogram(DISubprogram(Scope));
+  if (DISubprogram SP = dyn_cast<MDSubprogram>(Scope)) {
+    processSubprogram(SP);
     return;
   }
   if (!addScope(Scope))
     return;
-  if (Scope.isLexicalBlock()) {
-    DILexicalBlock LB(Scope);
+  if (DILexicalBlock LB = dyn_cast<MDLexicalBlockBase>(Scope)) {
     processScope(LB.getContext());
-  } else if (Scope.isNameSpace()) {
-    DINameSpace NS(Scope);
+  } else if (DINameSpace NS = dyn_cast<MDNamespace>(Scope)) {
     processScope(NS.getContext());
   }
 }
@@ -512,11 +505,11 @@ void DebugInfoFinder::processSubprogram(DISubprogram SP) {
   DIArray TParams = SP.getTemplateParams();
   for (unsigned I = 0, E = TParams.getNumElements(); I != E; ++I) {
     DIDescriptor Element = TParams.getElement(I);
-    if (Element.isTemplateTypeParameter()) {
-      DITemplateTypeParameter TType(Element);
+    if (DITemplateTypeParameter TType =
+            dyn_cast<MDTemplateTypeParameter>(Element)) {
       processType(TType.getType().resolve(TypeIdentifierMap));
-    } else if (Element.isTemplateValueParameter()) {
-      DITemplateValueParameter TVal(Element);
+    } else if (DITemplateValueParameter TVal =
+                   dyn_cast<MDTemplateValueParameter>(Element)) {
       processType(TVal.getType().resolve(TypeIdentifierMap));
     }
   }
@@ -529,14 +522,14 @@ void DebugInfoFinder::processDeclare(const Module &M,
     return;
   InitializeTypeMap(M);
 
-  DIDescriptor DV(N);
-  if (!DV.isVariable())
+  DIVariable DV = dyn_cast<MDLocalVariable>(N);
+  if (!DV)
     return;
 
   if (!NodesSeen.insert(DV).second)
     return;
-  processScope(DIVariable(N).getContext());
-  processType(DIVariable(N).getType().resolve(TypeIdentifierMap));
+  processScope(DV.getContext());
+  processType(DV.getType().resolve(TypeIdentifierMap));
 }
 
 void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
@@ -545,14 +538,14 @@ void DebugInfoFinder::processValue(const Module &M, const DbgValueInst *DVI) {
     return;
   InitializeTypeMap(M);
 
-  DIDescriptor DV(N);
-  if (!DV.isVariable())
+  DIVariable DV = dyn_cast<MDLocalVariable>(N);
+  if (!DV)
     return;
 
   if (!NodesSeen.insert(DV).second)
     return;
-  processScope(DIVariable(N).getContext());
-  processType(DIVariable(N).getType().resolve(TypeIdentifierMap));
+  processScope(DV.getContext());
+  processType(DV.getType().resolve(TypeIdentifierMap));
 }
 
 bool DebugInfoFinder::addType(DIType DT) {
@@ -631,8 +624,7 @@ static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS,
   if (!DL)
     return;
 
-  DIScope Scope(DL.getScope());
-  assert(Scope.isScope() && "Scope of a DebugLoc should be a DIScope.");
+  DIScope Scope = cast<MDScope>(DL.getScope());
   // Omit the directory, because it's likely to be long and uninteresting.
   CommentOS << Scope.getFilename();
   CommentOS << ':' << DL.getLine();
@@ -770,10 +762,10 @@ llvm::makeSubprogramMap(const Module &M) {
     return R;
 
   for (MDNode *N : CU_Nodes->operands()) {
-    DICompileUnit CUNode(N);
+    DICompileUnit CUNode = cast<MDCompileUnit>(N);
     DIArray SPs = CUNode.getSubprograms();
     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
-      DISubprogram SP(SPs.getElement(i));
+      DISubprogram SP = cast<MDSubprogram>(SPs.getElement(i));
       if (Function *F = SP.getFunction())
         R.insert(std::make_pair(F, SP));
     }
diff --git a/llvm/lib/IR/DebugLoc.cpp b/llvm/lib/IR/DebugLoc.cpp
index 95f6d67c542..df4802d9549 100644
--- a/llvm/lib/IR/DebugLoc.cpp
+++ b/llvm/lib/IR/DebugLoc.cpp
@@ -50,8 +50,7 @@ MDNode *DebugLoc::getInlinedAtScope() const {
 DebugLoc DebugLoc::getFnDebugLoc() const {
   // FIXME: Add a method on \a MDLocation that does this work.
   const MDNode *Scope = getInlinedAtScope();
-  DISubprogram SP = getDISubprogram(Scope);
-  if (SP.isSubprogram())
+  if (DISubprogram SP = getDISubprogram(Scope))
     return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
 
   return DebugLoc();
@@ -87,13 +86,8 @@ void DebugLoc::print(raw_ostream &OS) const {
     return;
 
   // Print source line info.
-  DIScope Scope(getScope());
-  assert((!Scope || Scope.isScope()) &&
-         "Scope of a DebugLoc should be null or a DIScope.");
-  if (Scope)
-    OS << Scope.getFilename();
-  else
-    OS << "<unknown>";
+  DIScope Scope = cast<MDScope>(getScope());
+  OS << Scope.getFilename();
   OS << ':' << getLine();
   if (getCol() != 0)
     OS << ':' << getCol();