1 files changed, 10 insertions, 8 deletions
diff --git a/clangd/ExpectedTypes.cpp b/clangd/ExpectedTypes.cpp
index 5c9cec89..59d9e149 100644
--- a/clangd/ExpectedTypes.cpp
+++ b/clangd/ExpectedTypes.cpp
@@ -5,8 +5,6 @@
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "llvm/ADT/STLExtras.h"
 
-using namespace llvm;
-
 namespace clang {
 namespace clangd {
 namespace {
@@ -33,11 +31,14 @@ static const Type *toEquivClass(ASTContext &Ctx, QualType T) {
   return T.getTypePtr();
 }
 
-static Optional<QualType> typeOfCompletion(const CodeCompletionResult &R) {
+static llvm::Optional<QualType>
+typeOfCompletion(const CodeCompletionResult &R) {
   auto *VD = dyn_cast_or_null<ValueDecl>(R.Declaration);
   if (!VD)
-    return None; // We handle only variables and functions below.
+    return llvm::None; // We handle only variables and functions below.
   auto T = VD->getType();
+  if (T.isNull())
+    return llvm::None;
   if (auto FuncT = T->getAs<FunctionType>()) {
     // Functions are a special case. They are completed as 'foo()' and we want
     // to match their return type rather than the function type itself.
@@ -49,13 +50,13 @@ static Optional<QualType> typeOfCompletion(const CodeCompletionResult &R) {
 }
 } // namespace
 
-Optional<OpaqueType> OpaqueType::encode(ASTContext &Ctx, QualType T) {
+llvm::Optional<OpaqueType> OpaqueType::encode(ASTContext &Ctx, QualType T) {
   if (T.isNull())
     return None;
   const Type *C = toEquivClass(Ctx, T);
   if (!C)
     return None;
-  SmallString<128> Encoded;
+  llvm::SmallString<128> Encoded;
   if (index::generateUSRForType(QualType(C, 0), Ctx, Encoded))
     return None;
   return OpaqueType(Encoded.str());
@@ -63,11 +64,12 @@ Optional<OpaqueType> OpaqueType::encode(ASTContext &Ctx, QualType T) {
 
 OpaqueType::OpaqueType(std::string Data) : Data(std::move(Data)) {}
 
-Optional<OpaqueType> OpaqueType::fromType(ASTContext &Ctx, QualType Type) {
+llvm::Optional<OpaqueType> OpaqueType::fromType(ASTContext &Ctx,
+                                                QualType Type) {
   return encode(Ctx, Type);
 }
 
-Optional<OpaqueType>
+llvm::Optional<OpaqueType>
 OpaqueType::fromCompletionResult(ASTContext &Ctx,
                                  const CodeCompletionResult &R) {
   auto T = typeOfCompletion(R);