[index] Factor out the dependency between the core indexing walker and SourceKit

The goal is to be able to move the core IndexSwiftASTWalker code out of
SourceKit, leaving only the serialization bits behind.

Mostly this replaces some direct uses of UIdent strings with explicit
enums, and then adds the translation code to produce those enums and to
convert them into UIdents in SourceKit.

rdar://problem/22348041

tools/SourceKit/lib/SwiftLang/SwiftLangSupport.cpp

@@ -18,11 +18,12 @@
 #include "swift/AST/AST.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/USRGeneration.h"
+#include "swift/Basic/Fallthrough.h"
+#include "swift/Config.h"
 #include "swift/IDE/CodeCompletion.h"
 #include "swift/IDE/CodeCompletionCache.h"
 #include "swift/IDE/SyntaxModel.h"
 #include "swift/IDE/Utils.h"
-#include "swift/Config.h"
 
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
@@ -519,6 +520,98 @@ UIdent SwiftLangSupport::getUIDForSyntaxStructureElementKind(
   }
 }
 
+UIdent SwiftLangSupport::getUIDForSymbol(SymbolKind kind, SymbolSubKind subKind,
+                                         bool isRef) {
+
+#define UID_FOR(CLASS) isRef ? KindRef##CLASS : KindDecl##CLASS;
+
+#define SIMPLE_CASE(KIND) \
+  case SymbolKind::KIND: \
+    return UID_FOR(KIND);
+
+  switch (kind) {
+  SIMPLE_CASE(Enum)
+  SIMPLE_CASE(Struct)
+  SIMPLE_CASE(Class)
+  SIMPLE_CASE(Protocol)
+  SIMPLE_CASE(TypeAlias)
+  SIMPLE_CASE(AssociatedType)
+  SIMPLE_CASE(GenericTypeParam)
+  SIMPLE_CASE(Subscript)
+  SIMPLE_CASE(EnumElement)
+  SIMPLE_CASE(Constructor)
+  SIMPLE_CASE(Destructor)
+
+  case SymbolKind::Function:
+    return UID_FOR(FunctionFree);
+  case SymbolKind::PrefixOperator:
+    return UID_FOR(FunctionPrefixOperator);
+  case SymbolKind::PostfixOperator:
+    return UID_FOR(FunctionPostfixOperator);
+  case SymbolKind::InfixOperator:
+    return UID_FOR(FunctionInfixOperator);
+  case SymbolKind::LocalVariable:
+    return UID_FOR(VarLocal);
+  case SymbolKind::GlobalVariable:
+    return UID_FOR(VarGlobal);
+  case SymbolKind::ParamVariable:
+    // There is no KindRefVarParam. It's not usually an interesting difference.
+    return isRef ? KindRefVarLocal : KindDeclVarParam;
+  case SymbolKind::InstanceMethod:
+    return UID_FOR(MethodInstance);
+  case SymbolKind::ClassMethod:
+    return UID_FOR(MethodClass);
+  case SymbolKind::StaticMethod:
+    return UID_FOR(MethodStatic);
+  case SymbolKind::InstanceProperty:
+    return UID_FOR(VarInstance);
+  case SymbolKind::ClassProperty:
+    return UID_FOR(VarClass);
+  case SymbolKind::StaticProperty:
+    return UID_FOR(VarStatic);
+
+  case SymbolKind::Extension:
+    assert(!isRef && "reference to extension decl?");
+    SWIFT_FALLTHROUGH;
+  case SymbolKind::Accessor:
+    switch (subKind) {
+    case SymbolSubKind::AccessorGetter:
+      return UID_FOR(AccessorGetter);
+    case SymbolSubKind::AccessorSetter:
+      return UID_FOR(AccessorSetter);
+    case SymbolSubKind::AccessorWillSet:
+      return UID_FOR(AccessorWillSet);
+    case SymbolSubKind::AccessorDidSet:
+      return UID_FOR(AccessorDidSet);
+    case SymbolSubKind::AccessorMaterializeForSet:
+      llvm_unreachable("unexpected MaterializeForSet");
+    case SymbolSubKind::AccessorAddressor:
+      return UID_FOR(AccessorAddress);
+    case SymbolSubKind::AccessorMutableAddressor:
+      return UID_FOR(AccessorMutableAddress);
+
+    case SymbolSubKind::ExtensionOfStruct:
+      return KindDeclExtensionStruct;
+    case SymbolSubKind::ExtensionOfClass:
+      return KindDeclExtensionClass;
+    case SymbolSubKind::ExtensionOfEnum:
+      return KindDeclExtensionEnum;
+    case SymbolSubKind::ExtensionOfProtocol:
+      return KindDeclExtensionProtocol;
+
+    case SymbolSubKind::None:
+      llvm_unreachable("missing sub kind");
+    }
+
+  default:
+    // TODO: reconsider whether having a default case is a good idea.
+    return UIdent();
+  }
+
+#undef SIMPLE_CASE
+#undef UID_FOR
+}
+
 bool SwiftLangSupport::printDisplayName(const swift::ValueDecl *D,
                                         llvm::raw_ostream &OS) {
   if (!D->hasName())