text: //===--- SwiftLangSupport.cpp ---------------------------------------------===//
  //
  // This source file is part of the Swift.org open source project
  //
  // Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
  // Licensed under Apache License v2.0 with Runtime Library Exception
  //
  // See https://swift.org/LICENSE.txt for license information
  // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
  //
  //===----------------------------------------------------------------------===//
  
  #include "SwiftLangSupport.h"
  #include "SwiftASTManager.h"
  #include "SourceKit/Core/Context.h"
  #include "SourceKit/SwiftLang/Factory.h"
  #include "SourceKit/Support/UIdent.h"
  
  #include "swift/AST/ASTVisitor.h"
  #include "swift/AST/ClangModuleLoader.h"
  #include "swift/AST/USRGeneration.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 "clang/Lex/HeaderSearch.h"
  #include "clang/Lex/Preprocessor.h"
  #include "llvm/ADT/APInt.h"
  #include "llvm/ADT/Hashing.h"
  #include "llvm/Support/ErrorHandling.h"
  #include "llvm/Support/Path.h"
  #include "llvm/Support/raw_ostream.h"
  
  #if !defined(_WIN32)
  #include <sys/param.h>
  #else
  #define WIN32_MEAN_AND_LEAN
  #define NOMINMAX
  #include <windows.h>
  #endif
  
  using namespace SourceKit;
  using namespace swift;
  using namespace swift::ide;
  using swift::index::SymbolKind;
  using swift::index::SymbolSubKind;
  using swift::index::SymbolProperty;
  using swift::index::SymbolPropertySet;
  using swift::index::SymbolInfo;
  using swift::index::SymbolRole;
  using swift::index::SymbolRoleSet;
  
  static UIdent KindDeclFunctionFree("source.lang.swift.decl.function.free");
  static UIdent KindRefFunctionFree("source.lang.swift.ref.function.free");
  static UIdent KindDeclMethodInstance(
        "source.lang.swift.decl.function.method.instance");
  static UIdent KindRefMethodInstance(
        "source.lang.swift.ref.function.method.instance");
  static UIdent KindDeclMethodStatic(
        "source.lang.swift.decl.function.method.static");
  static UIdent KindRefMethodStatic(
        "source.lang.swift.ref.function.method.static");
  static UIdent KindDeclMethodClass(
        "source.lang.swift.decl.function.method.class");
  static UIdent KindRefMethodClass(
        "source.lang.swift.ref.function.method.class");
  static UIdent KindDeclAccessorGetter(
        "source.lang.swift.decl.function.accessor.getter");
  static UIdent KindRefAccessorGetter(
        "source.lang.swift.ref.function.accessor.getter");
  static UIdent KindDeclAccessorSetter(
        "source.lang.swift.decl.function.accessor.setter");
  static UIdent KindRefAccessorSetter(
        "source.lang.swift.ref.function.accessor.setter");
  static UIdent KindDeclAccessorWillSet(
        "source.lang.swift.decl.function.accessor.willset");
  static UIdent KindRefAccessorWillSet(
        "source.lang.swift.ref.function.accessor.willset");
  static UIdent KindDeclAccessorDidSet(
        "source.lang.swift.decl.function.accessor.didset");
  static UIdent KindRefAccessorDidSet(
        "source.lang.swift.ref.function.accessor.didset");
  static UIdent KindDeclAccessorAddress(
        "source.lang.swift.decl.function.accessor.address");
  static UIdent KindRefAccessorAddress(
        "source.lang.swift.ref.function.accessor.address");
  static UIdent KindDeclAccessorMutableAddress(
        "source.lang.swift.decl.function.accessor.mutableaddress");
  static UIdent KindRefAccessorMutableAddress(
        "source.lang.swift.ref.function.accessor.mutableaddress");
  static UIdent KindDeclConstructor("source.lang.swift.decl.function.constructor");
  static UIdent KindRefConstructor("source.lang.swift.ref.function.constructor");
  static UIdent KindDeclDestructor("source.lang.swift.decl.function.destructor");
  static UIdent KindRefDestructor("source.lang.swift.ref.function.destructor");
  static UIdent KindDeclFunctionPrefixOperator("source.lang.swift.decl.function.operator.prefix");
  static UIdent KindDeclFunctionPostfixOperator("source.lang.swift.decl.function.operator.postfix");
  static UIdent KindDeclFunctionInfixOperator("source.lang.swift.decl.function.operator.infix");
  static UIdent KindRefFunctionPrefixOperator("source.lang.swift.ref.function.operator.prefix");
  static UIdent KindRefFunctionPostfixOperator("source.lang.swift.ref.function.operator.postfix");
  static UIdent KindRefFunctionInfixOperator("source.lang.swift.ref.function.operator.infix");
  static UIdent KindDeclPrecedenceGroup("source.lang.swift.decl.precedencegroup");
  static UIdent KindRefPrecedenceGroup("source.lang.swift.ref.precedencegroup");
  static UIdent KindDeclSubscript("source.lang.swift.decl.function.subscript");
  static UIdent KindRefSubscript("source.lang.swift.ref.function.subscript");
  static UIdent KindDeclVarGlobal("source.lang.swift.decl.var.global");
  static UIdent KindRefVarGlobal("source.lang.swift.ref.var.global");
  static UIdent KindDeclVarInstance("source.lang.swift.decl.var.instance");
  static UIdent KindRefVarInstance("source.lang.swift.ref.var.instance");
  static UIdent KindDeclVarStatic("source.lang.swift.decl.var.static");
  static UIdent KindRefVarStatic("source.lang.swift.ref.var.static");
  static UIdent KindDeclVarClass("source.lang.swift.decl.var.class");
  static UIdent KindRefVarClass("source.lang.swift.ref.var.class");
  static UIdent KindDeclVarLocal("source.lang.swift.decl.var.local");
  static UIdent KindRefVarLocal("source.lang.swift.ref.var.local");
  static UIdent KindDeclVarParam("source.lang.swift.decl.var.parameter");
  static UIdent KindDeclModule("source.lang.swift.decl.module");
  static UIdent KindDeclClass("source.lang.swift.decl.class");
  static UIdent KindRefClass("source.lang.swift.ref.class");
  static UIdent KindDeclStruct("source.lang.swift.decl.struct");
  static UIdent KindRefStruct("source.lang.swift.ref.struct");
  static UIdent KindDeclEnum("source.lang.swift.decl.enum");
  static UIdent KindRefEnum("source.lang.swift.ref.enum");
  static UIdent KindDeclEnumCase("source.lang.swift.decl.enumcase");
  static UIdent KindDeclEnumElement("source.lang.swift.decl.enumelement");
  static UIdent KindRefEnumElement("source.lang.swift.ref.enumelement");
  static UIdent KindDeclProtocol("source.lang.swift.decl.protocol");
  static UIdent KindRefProtocol("source.lang.swift.ref.protocol");
  static UIdent KindDeclExtension("source.lang.swift.decl.extension");
  static UIdent KindDeclExtensionStruct("source.lang.swift.decl.extension.struct");
  static UIdent KindDeclExtensionClass("source.lang.swift.decl.extension.class");
  static UIdent KindDeclExtensionEnum("source.lang.swift.decl.extension.enum");
  static UIdent KindDeclExtensionProtocol("source.lang.swift.decl.extension.protocol");
  static UIdent KindDeclAssociatedType("source.lang.swift.decl.associatedtype");
  static UIdent KindRefAssociatedType("source.lang.swift.ref.associatedtype");
  static UIdent KindDeclTypeAlias("source.lang.swift.decl.typealias");
  static UIdent KindRefTypeAlias("source.lang.swift.ref.typealias");
  static UIdent KindDeclGenericTypeParam("source.lang.swift.decl.generic_type_param");
  static UIdent KindRefGenericTypeParam("source.lang.swift.ref.generic_type_param");
  static UIdent KindRefModule("source.lang.swift.ref.module");
  static UIdent KindStmtForEach("source.lang.swift.stmt.foreach");
  static UIdent KindStmtFor("source.lang.swift.stmt.for");
  static UIdent KindStmtWhile("source.lang.swift.stmt.while");
  static UIdent KindStmtRepeatWhile("source.lang.swift.stmt.repeatwhile");
  static UIdent KindStmtIf("source.lang.swift.stmt.if");
  static UIdent KindStmtGuard("source.lang.swift.stmt.guard");
  static UIdent KindStmtSwitch("source.lang.swift.stmt.switch");
  static UIdent KindStmtCase("source.lang.swift.stmt.case");
  static UIdent KindStmtBrace("source.lang.swift.stmt.brace");
  static UIdent KindExprCall("source.lang.swift.expr.call");
  static UIdent KindExprArg("source.lang.swift.expr.argument");
  static UIdent KindExprArray("source.lang.swift.expr.array");
  static UIdent KindExprDictionary("source.lang.swift.expr.dictionary");
  static UIdent KindExprObjectLiteral("source.lang.swift.expr.object_literal");
  
  static UIdent KindStructureElemId("source.lang.swift.structure.elem.id");
  static UIdent KindStructureElemExpr("source.lang.swift.structure.elem.expr");
  static UIdent KindStructureElemInitExpr("source.lang.swift.structure.elem.init_expr");
  static UIdent KindStructureElemCondExpr("source.lang.swift.structure.elem.condition_expr");
  static UIdent KindStructureElemPattern("source.lang.swift.structure.elem.pattern");
  static UIdent KindStructureElemTypeRef("source.lang.swift.structure.elem.typeref");
  
  static UIdent KindRangeSingleStatement("source.lang.swift.range.singlestatement");
  static UIdent KindRangeSingleExpression("source.lang.swift.range.singleexpression");
  static UIdent KindRangeSingleDeclaration("source.lang.swift.range.singledeclaration");
  
  static UIdent KindRangeMultiStatement("source.lang.swift.range.multistatement");
  
  static UIdent KindRangeInvalid("source.lang.swift.range.invalid");
  
  static UIdent KindNameObjc("source.lang.name.kind.objc");
  static UIdent KindNameSwift("source.lang.name.kind.swift");
  
  
  std::unique_ptr<LangSupport>
  SourceKit::createSwiftLangSupport(SourceKit::Context &SKCtx) {
    return std::unique_ptr<LangSupport>(new SwiftLangSupport(SKCtx));
  }
  
  const std::string LangSupport::SynthesizedUSRSeparator = "::SYNTHESIZED::";
  
  namespace {
  
  class UIdentVisitor : public ASTVisitor<UIdentVisitor,
                                          UIdent, UIdent, UIdent, UIdent > {
    const bool IsRef;
  
  public:
    explicit UIdentVisitor(bool IsRef) : IsRef(IsRef) { }
  
    /// TODO: reconsider whether having a default case is a good idea.
    UIdent visitDecl(const Decl *D) { return UIdent(); }
  
    UIdent visitFuncDecl(const FuncDecl *D);
    UIdent visitVarDecl(const VarDecl *D);
    UIdent visitParamDecl(const ParamDecl *D);
    UIdent visitExtensionDecl(const ExtensionDecl *D);
  
  #define UID_FOR(CLASS) \
    UIdent visit##CLASS##Decl(const CLASS##Decl *) { \
      return IsRef ? KindRef##CLASS : KindDecl##CLASS; \
    }
    UID_FOR(Class)
    UID_FOR(Struct)
    UID_FOR(Enum)
    UID_FOR(EnumElement)
    UID_FOR(Protocol)
    UID_FOR(TypeAlias)
    UID_FOR(AssociatedType)
    UID_FOR(GenericTypeParam)
    UID_FOR(Constructor)
    UID_FOR(Destructor)
    UID_FOR(Subscript)
  #undef UID_FOR
  };
  
  } // anonymous namespace
  
  UIdent UIdentVisitor::visitFuncDecl(const FuncDecl *D) {
    if (D->isAccessor()) {
      return SwiftLangSupport::getUIDForAccessor(D->getAccessorStorageDecl(),
                                                 D->getAccessorKind(),
                                                 IsRef);
    }
  
    if (auto *Op = D->getOperatorDecl()) {
      switch (Op->getKind()) {
      case DeclKind::PrefixOperator:
        return IsRef ? KindRefFunctionPrefixOperator : KindDeclFunctionPrefixOperator;
      case DeclKind::PostfixOperator:
        return IsRef ? KindRefFunctionPostfixOperator : KindDeclFunctionPostfixOperator;
      case DeclKind::InfixOperator:
        return IsRef ? KindRefFunctionInfixOperator : KindDeclFunctionInfixOperator;
      default:
        llvm_unreachable("unexpected operator kind");
      }
    }
  
    const DeclContext *DC = D->getDeclContext();
    if (DC->isTypeContext()) {
      if (D->isStatic()) {
        if (D->getCorrectStaticSpelling() == StaticSpellingKind::KeywordClass)
          return IsRef ? KindRefMethodClass : KindDeclMethodClass;
        else
          return IsRef ? KindRefMethodStatic : KindDeclMethodStatic;
      }
      return IsRef ? KindRefMethodInstance : KindDeclMethodInstance;
    }
    return IsRef ? KindRefFunctionFree : KindDeclFunctionFree;
  }
  
  UIdent UIdentVisitor::visitVarDecl(const VarDecl *D) {
    const DeclContext *DC = D->getDeclContext();
    if (DC->isTypeContext()) {
      if (D->isStatic()) {
        if (D->getCorrectStaticSpelling() == StaticSpellingKind::KeywordClass)
          return IsRef ? KindRefVarClass : KindDeclVarClass;
        else
          return IsRef ? KindRefVarStatic : KindDeclVarStatic;
      }
      return IsRef ? KindRefVarInstance : KindDeclVarInstance;
    }
    if (DC->isLocalContext())
      return IsRef ? KindRefVarLocal : KindDeclVarLocal;
    return IsRef ? KindRefVarGlobal : KindDeclVarGlobal;
  }
  
  UIdent UIdentVisitor::visitParamDecl(const ParamDecl *D) {
    // There is no KindRefVarParam. It's not usually an interesting difference.
    return IsRef ? KindRefVarLocal : KindDeclVarParam;
  }
  
  UIdent UIdentVisitor::visitExtensionDecl(const ExtensionDecl *D) {
    assert(!IsRef && "reference to an extension ?");
    if (NominalTypeDecl *NTD = D->getExtendedType()->getAnyNominal()) {
      if (isa<StructDecl>(NTD))
        return KindDeclExtensionStruct;
      if (isa<ClassDecl>(NTD))
        return KindDeclExtensionClass;
      if (isa<EnumDecl>(NTD))
        return KindDeclExtensionEnum;
      if (isa<ProtocolDecl>(NTD))
        return KindDeclExtensionProtocol;
    }
    return UIdent();
  }
  
  SwiftLangSupport::SwiftLangSupport(SourceKit::Context &SKCtx)
      : SKCtx(SKCtx), CCCache(new SwiftCompletionCache) {
    llvm::SmallString<128> LibPath(SKCtx.getRuntimeLibPath());
    llvm::sys::path::append(LibPath, "swift");
    RuntimeResourcePath = LibPath.str();
  
    ASTMgr.reset(new SwiftASTManager(*this));
    // By default, just use the in-memory cache.
    CCCache->inMemory = llvm::make_unique<ide::CodeCompletionCache>();
  }
  
  SwiftLangSupport::~SwiftLangSupport() {
  }
  
  UIdent SwiftLangSupport::getUIDForDecl(const Decl *D, bool IsRef) {
    return UIdentVisitor(IsRef).visit(const_cast<Decl*>(D));
  }
  
  UIdent SwiftLangSupport::getUIDForExtensionOfDecl(const Decl *D) {
    switch (D->getKind()) {
      case swift::DeclKind::Struct:
        return KindDeclExtensionStruct;
      case swift::DeclKind::Enum:
        return KindDeclExtensionEnum;
      case swift::DeclKind::Class:
        return KindDeclExtensionClass;
      case swift::DeclKind::Protocol:
        return KindDeclExtensionProtocol;
      default:
        llvm_unreachable("cannot have extension.");
    }
  }
  
  UIdent SwiftLangSupport::getUIDForLocalVar(bool IsRef) {
    return IsRef ? KindRefVarLocal : KindDeclVarLocal;
  }
  
  UIdent SwiftLangSupport::getUIDForAccessor(const ValueDecl *D,
                                             AccessorKind AccKind,
                                             bool IsRef) {
    switch (AccKind) {
    case AccessorKind::NotAccessor:
      llvm_unreachable("expected accessor");
    case AccessorKind::IsMaterializeForSet:
      llvm_unreachable("unexpected MaterializeForSet");
    case AccessorKind::IsGetter:
      return IsRef ? KindRefAccessorGetter : KindDeclAccessorGetter;
    case AccessorKind::IsSetter:
      return IsRef ? KindRefAccessorSetter : KindDeclAccessorSetter;
    case AccessorKind::IsWillSet:
      return IsRef ? KindRefAccessorWillSet : KindDeclAccessorWillSet;
    case AccessorKind::IsDidSet:
      return IsRef ? KindRefAccessorDidSet : KindDeclAccessorDidSet;
    case AccessorKind::IsAddressor:
      return IsRef ? KindRefAccessorAddress : KindDeclAccessorAddress;
    case AccessorKind::IsMutableAddressor:
      return IsRef ? KindRefAccessorMutableAddress
                   : KindDeclAccessorMutableAddress;
    }
  
    llvm_unreachable("Unhandled AccessorKind in switch.");
  }
  
  SourceKit::UIdent SwiftLangSupport::getUIDForModuleRef() {
    return KindRefModule;
  }
  
  UIdent SwiftLangSupport::getUIDForCodeCompletionDeclKind(
      ide::CodeCompletionDeclKind Kind, bool IsRef) {
    if (IsRef) {
      // FIXME: The code-completion kind is also used for semantic annotations.
      // We should either create a new kind or rename the code-completion kind to
      // something more general.
      switch (Kind) {
      case CodeCompletionDeclKind::Module: return KindRefModule;
      case CodeCompletionDeclKind::Class: return KindRefClass;
      case CodeCompletionDeclKind::Struct: return KindRefStruct;
      case CodeCompletionDeclKind::Enum: return KindRefEnum;
      case CodeCompletionDeclKind::EnumElement: return KindRefEnumElement;
      case CodeCompletionDeclKind::Protocol: return KindRefProtocol;
      case CodeCompletionDeclKind::AssociatedType: return KindRefAssociatedType;
      case CodeCompletionDeclKind::TypeAlias: return KindRefTypeAlias;
      case CodeCompletionDeclKind::GenericTypeParam: return KindRefGenericTypeParam;
      case CodeCompletionDeclKind::Constructor: return KindRefConstructor;
      case CodeCompletionDeclKind::Destructor: return KindRefDestructor;
      case CodeCompletionDeclKind::Subscript: return KindRefSubscript;
      case CodeCompletionDeclKind::StaticMethod: return KindRefMethodClass;
      case CodeCompletionDeclKind::InstanceMethod: return KindRefMethodInstance;
      case CodeCompletionDeclKind::PrefixOperatorFunction: return KindRefFunctionPrefixOperator;
      case CodeCompletionDeclKind::PostfixOperatorFunction: return KindRefFunctionPostfixOperator;
      case CodeCompletionDeclKind::InfixOperatorFunction: return KindRefFunctionInfixOperator;
      case CodeCompletionDeclKind::PrecedenceGroup: return KindRefPrecedenceGroup;
      case CodeCompletionDeclKind::FreeFunction: return KindRefFunctionFree;
      case CodeCompletionDeclKind::StaticVar: return KindRefVarClass;
      case CodeCompletionDeclKind::InstanceVar: return KindRefVarInstance;
      case CodeCompletionDeclKind::LocalVar: return KindRefVarLocal;
      case CodeCompletionDeclKind::GlobalVar: return KindRefVarGlobal;
      }
    }
  
    switch (Kind) {
    case CodeCompletionDeclKind::Module: return KindDeclModule;
    case CodeCompletionDeclKind::Class: return KindDeclClass;
    case CodeCompletionDeclKind::Struct: return KindDeclStruct;
    case CodeCompletionDeclKind::Enum: return KindDeclEnum;
    case CodeCompletionDeclKind::EnumElement: return KindDeclEnumElement;
    case CodeCompletionDeclKind::Protocol: return KindDeclProtocol;
    case CodeCompletionDeclKind::AssociatedType: return KindDeclAssociatedType;
    case CodeCompletionDeclKind::TypeAlias: return KindDeclTypeAlias;
    case CodeCompletionDeclKind::GenericTypeParam: return KindDeclGenericTypeParam;
    case CodeCompletionDeclKind::Constructor: return KindDeclConstructor;
    case CodeCompletionDeclKind::Destructor: return KindDeclDestructor;
    case CodeCompletionDeclKind::Subscript: return KindDeclSubscript;
    case CodeCompletionDeclKind::StaticMethod: return KindDeclMethodClass;
    case CodeCompletionDeclKind::InstanceMethod: return KindDeclMethodInstance;
    case CodeCompletionDeclKind::PrefixOperatorFunction: return KindDeclFunctionPrefixOperator;
    case CodeCompletionDeclKind::PostfixOperatorFunction: return KindDeclFunctionPostfixOperator;
    case CodeCompletionDeclKind::InfixOperatorFunction: return KindDeclFunctionInfixOperator;
    case CodeCompletionDeclKind::PrecedenceGroup: return KindDeclPrecedenceGroup;
    case CodeCompletionDeclKind::FreeFunction: return KindDeclFunctionFree;
    case CodeCompletionDeclKind::StaticVar: return KindDeclVarClass;
    case CodeCompletionDeclKind::InstanceVar: return KindDeclVarInstance;
    case CodeCompletionDeclKind::LocalVar: return KindDeclVarLocal;
    case CodeCompletionDeclKind::GlobalVar: return KindDeclVarGlobal;
    }
  
    llvm_unreachable("Unhandled CodeCompletionDeclKind in switch.");
  }
  
  UIdent SwiftLangSupport::getUIDForSyntaxNodeKind(SyntaxNodeKind SC) {
    static UIdent KindKeyword("source.lang.swift.syntaxtype.keyword");
    static UIdent KindIdentifier("source.lang.swift.syntaxtype.identifier");
    static UIdent KindTypeIdentifier("source.lang.swift.syntaxtype.typeidentifier");
    static UIdent KindBuildConfigKeyword("source.lang.swift.syntaxtype.buildconfig.keyword");
    static UIdent KindBuildConfigId("source.lang.swift.syntaxtype.buildconfig.id");
    static UIdent KindAttributeId("source.lang.swift.syntaxtype.attribute.id");
    static UIdent KindAttributeBuiltin("source.lang.swift.syntaxtype.attribute.builtin");
    static UIdent KindNumber("source.lang.swift.syntaxtype.number");
    static UIdent KindString("source.lang.swift.syntaxtype.string");
    static UIdent KindStringInterpolation("source.lang.swift.syntaxtype.string_interpolation_anchor");
    static UIdent KindComment("source.lang.swift.syntaxtype.comment");
    static UIdent KindDocComment("source.lang.swift.syntaxtype.doccomment");
    static UIdent KindDocCommentField("source.lang.swift.syntaxtype.doccomment.field");
    static UIdent KindCommentMarker("source.lang.swift.syntaxtype.comment.mark");
    static UIdent KindCommentURL("source.lang.swift.syntaxtype.comment.url");
    static UIdent KindPlaceholder("source.lang.swift.syntaxtype.placeholder");
    static UIdent KindObjectLiteral("source.lang.swift.syntaxtype.objectliteral");
  
    switch (SC) {
    case SyntaxNodeKind::Keyword:
      return KindKeyword;
    case SyntaxNodeKind::Identifier:
    case SyntaxNodeKind::DollarIdent:
      return KindIdentifier;
    case SyntaxNodeKind::Integer:
    case SyntaxNodeKind::Floating:
      return KindNumber;
    case SyntaxNodeKind::String:
      return KindString;
    case SyntaxNodeKind::StringInterpolationAnchor:
      return KindStringInterpolation;
    case SyntaxNodeKind::CommentLine:
    case SyntaxNodeKind::CommentBlock:
      return KindComment;
    case SyntaxNodeKind::CommentMarker:
      return KindCommentMarker;
    case SyntaxNodeKind::CommentURL:
      return KindCommentURL;
    case SyntaxNodeKind::DocCommentLine:
    case SyntaxNodeKind::DocCommentBlock:
      return KindDocComment;
    case SyntaxNodeKind::DocCommentField:
      return KindDocCommentField;
    case SyntaxNodeKind::TypeId:
      return KindTypeIdentifier;
    case SyntaxNodeKind::BuildConfigKeyword:
      return KindBuildConfigKeyword;
    case SyntaxNodeKind::BuildConfigId:
      return KindBuildConfigId;
    case SyntaxNodeKind::AttributeId:
      return KindAttributeId;
    case SyntaxNodeKind::AttributeBuiltin:
      return KindAttributeBuiltin;
    case SyntaxNodeKind::EditorPlaceholder:
      return KindPlaceholder;
    case SyntaxNodeKind::ObjectLiteral:
      return KindObjectLiteral;
    }
  
    llvm_unreachable("Unhandled SyntaxNodeKind in switch.");
  }
  
  UIdent SwiftLangSupport::getUIDForSyntaxStructureKind(
      SyntaxStructureKind Kind) {
    switch (Kind) {
      case SyntaxStructureKind::Class:
        return KindDeclClass;
      case SyntaxStructureKind::Struct:
        return KindDeclStruct;
      case SyntaxStructureKind::Protocol:
        return KindDeclProtocol;
      case SyntaxStructureKind::Enum:
        return KindDeclEnum;
      case SyntaxStructureKind::Extension:
        return KindDeclExtension;
      case SyntaxStructureKind::FreeFunction:
        return KindDeclFunctionFree;
      case SyntaxStructureKind::InstanceFunction:
        return KindDeclMethodInstance;
      case SyntaxStructureKind::StaticFunction:
        return KindDeclMethodStatic;
      case SyntaxStructureKind::ClassFunction:
        return KindDeclMethodClass;
      case SyntaxStructureKind::GlobalVariable:
        return KindDeclVarGlobal;
      case SyntaxStructureKind::InstanceVariable:
        return KindDeclVarInstance;
      case SyntaxStructureKind::StaticVariable:
        return KindDeclVarStatic;
      case SyntaxStructureKind::ClassVariable:
        return KindDeclVarClass;
      case SyntaxStructureKind::EnumCase:
        return KindDeclEnumCase;
      case SyntaxStructureKind::EnumElement:
        return KindDeclEnumElement;
      case SyntaxStructureKind::Parameter:
        return KindDeclVarParam;
      case SyntaxStructureKind::ForEachStatement:
        return KindStmtForEach;
      case SyntaxStructureKind::ForStatement:
        return KindStmtFor;
      case SyntaxStructureKind::WhileStatement:
        return KindStmtWhile;
      case SyntaxStructureKind::RepeatWhileStatement:
        return KindStmtRepeatWhile;
      case SyntaxStructureKind::IfStatement:
        return KindStmtIf;
      case SyntaxStructureKind::GuardStatement:
        return KindStmtGuard;
      case SyntaxStructureKind::SwitchStatement:
        return KindStmtSwitch;
      case SyntaxStructureKind::CaseStatement:
        return KindStmtCase;
      case SyntaxStructureKind::BraceStatement:
        return KindStmtBrace;
      case SyntaxStructureKind::CallExpression:
        return KindExprCall;
      case SyntaxStructureKind::ArrayExpression:
        return KindExprArray;
      case SyntaxStructureKind::DictionaryExpression:
        return KindExprDictionary;
      case SyntaxStructureKind::ObjectLiteralExpression:
        return KindExprObjectLiteral;
      case SyntaxStructureKind::Argument:
        return KindExprArg;
    }
  
    llvm_unreachable("Unhandled SyntaxStructureKind in switch.");
  }
  
  UIdent SwiftLangSupport::getUIDForSyntaxStructureElementKind(
      SyntaxStructureElementKind Kind) {
    switch (Kind) {
      case SyntaxStructureElementKind::Id: return KindStructureElemId;
      case SyntaxStructureElementKind::Expr: return KindStructureElemExpr;
      case SyntaxStructureElementKind::InitExpr: return KindStructureElemInitExpr;
      case SyntaxStructureElementKind::ConditionExpr: return KindStructureElemCondExpr;
      case SyntaxStructureElementKind::Pattern: return KindStructureElemPattern;
      case SyntaxStructureElementKind::TypeRef: return KindStructureElemTypeRef;
    }
  
    llvm_unreachable("Unhandled SyntaxStructureElementKind in switch.");
  }
  
  SourceKit::UIdent SwiftLangSupport::
  getUIDForRangeKind(swift::ide::RangeKind Kind) {
    switch (Kind) {
      case swift::ide::RangeKind::SingleExpression: return KindRangeSingleExpression;
      case swift::ide::RangeKind::SingleStatement: return KindRangeSingleStatement;
      case swift::ide::RangeKind::SingleDecl: return KindRangeSingleDeclaration;
      case swift::ide::RangeKind::MultiStatement: return KindRangeMultiStatement;
      case swift::ide::RangeKind::PartOfExpression: return KindRangeInvalid;
      case swift::ide::RangeKind::Invalid: return KindRangeInvalid;
    }
  
    llvm_unreachable("Unhandled RangeKind in switch.");
  }
  
  UIdent SwiftLangSupport::getUIDForSymbol(SymbolInfo sym, bool isRef) {
  
  #define UID_FOR(CLASS) isRef ? KindRef##CLASS : KindDecl##CLASS;
  
    switch (sym.SubKind) {
    default: break;
    case SymbolSubKind::AccessorGetter: return UID_FOR(AccessorGetter);
    case SymbolSubKind::AccessorSetter: return UID_FOR(AccessorSetter);
    case SymbolSubKind::SwiftAccessorWillSet: return UID_FOR(AccessorWillSet);
    case SymbolSubKind::SwiftAccessorDidSet: return UID_FOR(AccessorDidSet);
    case SymbolSubKind::SwiftAccessorAddressor: return UID_FOR(AccessorAddress);
    case SymbolSubKind::SwiftAccessorMutableAddressor: return UID_FOR(AccessorMutableAddress);
    }
  
  #define SIMPLE_CASE(KIND) \
    case SymbolKind::KIND: \
      return UID_FOR(KIND);
  
    switch (sym.Kind) {
    SIMPLE_CASE(Enum)
    SIMPLE_CASE(Struct)
    SIMPLE_CASE(Class)
    SIMPLE_CASE(Protocol)
    SIMPLE_CASE(Constructor)
    SIMPLE_CASE(Destructor)
  
    case SymbolKind::EnumConstant:
      return UID_FOR(EnumElement);
  
    case SymbolKind::TypeAlias:
      if (sym.SubKind == SymbolSubKind::SwiftAssociatedType)
        return UID_FOR(AssociatedType);
      if (sym.SubKind == SymbolSubKind::SwiftGenericTypeParam)
        return UID_FOR(GenericTypeParam);
      return UID_FOR(TypeAlias);
  
    case SymbolKind::Function:
      if (sym.SubKind == SymbolSubKind::SwiftPrefixOperator)
        return UID_FOR(FunctionPrefixOperator);
      if (sym.SubKind == SymbolSubKind::SwiftPostfixOperator)
        return UID_FOR(FunctionPostfixOperator);
      if (sym.SubKind == SymbolSubKind::SwiftInfixOperator)
        return UID_FOR(FunctionInfixOperator);
      return UID_FOR(FunctionFree);
    case SymbolKind::Variable:
      return UID_FOR(VarGlobal);
    case SymbolKind::InstanceMethod:
      return UID_FOR(MethodInstance);
    case SymbolKind::ClassMethod:
      return UID_FOR(MethodClass);
    case SymbolKind::StaticMethod:
      return UID_FOR(MethodStatic);
    case SymbolKind::InstanceProperty:
      if (sym.SubKind == SymbolSubKind::SwiftSubscript)
        return UID_FOR(Subscript);
      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?");
      if (sym.SubKind == SymbolSubKind::SwiftExtensionOfStruct) {
        return KindDeclExtensionStruct;
      } else if (sym.SubKind == SymbolSubKind::SwiftExtensionOfClass) {
        return KindDeclExtensionClass;
      } else if (sym.SubKind == SymbolSubKind::SwiftExtensionOfEnum) {
        return KindDeclExtensionEnum;
      } else if (sym.SubKind == SymbolSubKind::SwiftExtensionOfProtocol) {
        return KindDeclExtensionProtocol;
      } else {
        llvm_unreachable("missing extension sub kind");
      }
  
    default:
      // TODO: reconsider whether having a default case is a good idea.
      return UIdent();
    }
  
  #undef SIMPLE_CASE
  #undef UID_FOR
  }
  
  SourceKit::UIdent SwiftLangSupport::getUIDForNameKind(swift::ide::NameKind Kind) {
    switch(Kind) {
    case swift::ide::NameKind::ObjC: return KindNameObjc;
    case swift::ide::NameKind::Swift: return KindNameSwift;
    }
  
    llvm_unreachable("Unhandled NameKind in switch.");
  }
  
  swift::ide::NameKind SwiftLangSupport::getNameKindForUID(SourceKit::UIdent Id) {
    if (Id == KindNameObjc)
      return swift::ide::NameKind::ObjC;
    assert(Id == KindNameSwift);
    return swift::ide::NameKind::Swift;
  }
  
  std::vector<UIdent> SwiftLangSupport::UIDsFromDeclAttributes(const DeclAttributes &Attrs) {
    std::vector<UIdent> AttrUIDs;
  
  #define ATTR(X) \
    if (Attrs.has(AK_##X)) { \
      static UIdent Attr_##X("source.decl.attribute."#X); \
      AttrUIDs.push_back(Attr_##X); \
    }
  #include "swift/AST/Attr.def"
  
    for (auto Attr : Attrs) {
      // Check special-case names first.
      switch (Attr->getKind()) {
      case DAK_IBAction: {
        static UIdent Attr_IBAction("source.decl.attribute.ibaction");
        AttrUIDs.push_back(Attr_IBAction);
        continue;
      }
      case DAK_IBOutlet: {
        static UIdent Attr_IBOutlet("source.decl.attribute.iboutlet");
        AttrUIDs.push_back(Attr_IBOutlet);
        continue;
      }
      case DAK_IBDesignable: {
        static UIdent Attr_IBDesignable("source.decl.attribute.ibdesignable");
        AttrUIDs.push_back(Attr_IBDesignable);
        continue;
      }
      case DAK_IBInspectable: {
        static UIdent Attr_IBInspectable("source.decl.attribute.ibinspectable");
        AttrUIDs.push_back(Attr_IBInspectable);
        continue;
      }
      case DAK_GKInspectable: {
        static UIdent Attr_GKInspectable("source.decl.attribute.gkinspectable");
        AttrUIDs.push_back(Attr_GKInspectable);
        continue;
      }
      case DAK_ObjC: {
        static UIdent Attr_Objc("source.decl.attribute.objc");
        static UIdent Attr_ObjcNamed("source.decl.attribute.objc.name");
        if (cast<ObjCAttr>(Attr)->hasName()) {
          AttrUIDs.push_back(Attr_ObjcNamed);
        } else {
          AttrUIDs.push_back(Attr_Objc);
        }
        continue;
      }
  
      // We handle accessibility explicitly.
      case DAK_Accessibility:
      case DAK_SetterAccessibility:
      // Ignore these.
      case DAK_ShowInInterface:
      case DAK_RawDocComment:
      case DAK_DowngradeExhaustivityCheck:
        continue;
      default:
        break;
      }
  
      switch (Attr->getKind()) {
      case DAK_Count:
        break;
  #define DECL_ATTR(X, CLASS, ...)\
      case DAK_##CLASS: {\
        static UIdent Attr_##X("source.decl.attribute."#X); \
        AttrUIDs.push_back(Attr_##X); \
        break;\
      }
  #include "swift/AST/Attr.def"
      }
    }
  
    return AttrUIDs;
  }
  
  bool SwiftLangSupport::printDisplayName(const swift::ValueDecl *D,
                                          llvm::raw_ostream &OS) {
    if (!D->hasName())
      return true;
  
    OS << D->getFullName();
    return false;
  }
  
  bool SwiftLangSupport::printUSR(const ValueDecl *D, llvm::raw_ostream &OS) {
    return ide::printDeclUSR(D, OS);
  }
  
  bool SwiftLangSupport::printDeclTypeUSR(const ValueDecl *D, llvm::raw_ostream &OS) {
    return ide::printDeclTypeUSR(D, OS);
  }
  
  bool SwiftLangSupport::printTypeUSR(Type Ty, llvm::raw_ostream &OS) {
    return ide::printTypeUSR(Ty, OS);
  }
  
  bool SwiftLangSupport::printAccessorUSR(const AbstractStorageDecl *D,
                                          AccessorKind AccKind,
                                          llvm::raw_ostream &OS) {
    return ide::printAccessorUSR(D, AccKind, OS);
  }
  
  std::string SwiftLangSupport::resolvePathSymlinks(StringRef FilePath) {
    std::string InputPath = FilePath;
  #if !defined(_WIN32)
    char full_path[MAXPATHLEN];
    if (const char *path = realpath(InputPath.c_str(), full_path))
      return path;
  
    return InputPath;
  #else
    char full_path[MAX_PATH];
  
    HANDLE fileHandle = CreateFileA(
        InputPath.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING,
        FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, nullptr);
  
    if (fileHandle == INVALID_HANDLE_VALUE)
      return InputPath;
  
    DWORD success = GetFinalPathNameByHandleA(
        fileHandle, full_path, sizeof(full_path), FILE_NAME_NORMALIZED);
    return (success ? full_path : InputPath);
  #endif
  }
  
  CloseClangModuleFiles::~CloseClangModuleFiles() {
    clang::Preprocessor &PP = loader.getClangPreprocessor();
    clang::ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
    for (auto I = ModMap.module_begin(), E = ModMap.module_end(); I != E; ++I) {
      clang::Module *M = I->second;
      if (!M->isSubModule() && M->getASTFile())
        M->getASTFile()->closeFile();
    }
  }
  