//===--- ImportDecl.cpp - Import Clang Declarations -----------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file implements support for importing Clang declarations into Swift.
//
//===----------------------------------------------------------------------===//

#include "ImporterImpl.h"
#include "swift/AST/ASTContext.h"
#include "swift/AST/Attr.h"
#include "swift/AST/Decl.h"
#include "swift/AST/Expr.h"
#include "swift/AST/Module.h"
#include "swift/AST/NameLookup.h"
#include "swift/AST/Pattern.h"
#include "swift/AST/Stmt.h"
#include "swift/AST/Types.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Attr.h"
#include "clang/AST/DeclVisitor.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"

using namespace swift;

namespace {
  /// \brief Convert Clang declarations into the corresponding Swift
  /// declarations.
  class SwiftDeclConverter
    : public clang::DeclVisitor<SwiftDeclConverter, Decl *>
  {
    ClangImporter::Implementation &Impl;

  public:
    explicit SwiftDeclConverter(ClangImporter::Implementation &impl)
      : Impl(impl) { }

    Decl *VisitDecl(clang::Decl *decl) {
      return nullptr;
    }

    Decl *VisitTranslationUnitDecl(clang::TranslationUnitDecl *decl) {
      // Note: translation units are handled specially by importDeclContext.
      return nullptr;
    }

    Decl *VisitNamespaceDecl(clang::NamespaceDecl *decl) {
      // FIXME: Implement once Swift has namespaces.
      return nullptr;
    }

    Decl *VisitUsingDirectiveDecl(clang::UsingDirectiveDecl *decl) {
      // Never imported.
      return nullptr;
    }

    Decl *VisitNamespaceAliasDecl(clang::NamespaceAliasDecl *decl) {
      // FIXME: Implement once Swift has namespaces.
      return nullptr;
    }

    Decl *VisitLabelDecl(clang::LabelDecl *decl) {
      // Labels are function-local, and therefore never imported.
      return nullptr;
    }

    Decl *VisitTypedefNameDecl(clang::TypedefNameDecl *decl){
      auto name = Impl.importName(decl->getDeclName());
      if (name.empty())
        return nullptr;

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      Type type;

      // If this is the Objective-C BOOL type, map it to ObjCBool.
      auto &clangContext = Impl.getClangASTContext();
      if (clangContext.getLangOpts().ObjC1 &&
          name.str() == "BOOL" &&
          clangContext.hasSameType(decl->getUnderlyingType(),
                                   clangContext.ObjCBuiltinBoolTy)) {
        type = Impl.getNamedSwiftType(Impl.getNamedModule("objc"), "ObjCBool");
      } else {
        type = Impl.importType(decl->getUnderlyingType());
      }

      if (!type)
        return nullptr;

      auto loc = Impl.importSourceLoc(decl->getLocation());
      return new (Impl.SwiftContext) TypeAliasDecl(
                                      Impl.importSourceLoc(decl->getLocStart()),
                                      name,
                                      loc,
                                      TypeLoc(type, loc),
                                      dc,
                                      { });
    }

    Decl *
    VisitUnresolvedUsingTypenameDecl(clang::UnresolvedUsingTypenameDecl *decl) {
      // Note: only occurs in templates.
      return nullptr;
    }

    Decl *VisitEnumDecl(clang::EnumDecl *decl) {
      decl = decl->getDefinition();
      if (!decl)
        return nullptr;
      
      Identifier name;
      if (decl->getDeclName())
        name = Impl.importName(decl->getDeclName());
      else if (decl->getTypedefNameForAnonDecl())
        name =Impl.importName(decl->getTypedefNameForAnonDecl()->getDeclName());

      if (name.empty())
        return nullptr;

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      // Create the oneof declaration and record it.
      auto result = new (Impl.SwiftContext)
                      OneOfDecl(Impl.importSourceLoc(decl->getLocStart()),
                                name,
                                Impl.importSourceLoc(decl->getLocation()),
                                { }, nullptr, dc);
      Impl.ImportedDecls[decl->getCanonicalDecl()] = result;

      // Import each of the enumerators.
      SmallVector<Decl *, 4> members;
      for (auto ec = decl->enumerator_begin(), ecEnd = decl->enumerator_end();
           ec != ecEnd; ++ec) {
        auto ood = Impl.importDecl(*ec);
        if (!ood)
          continue;

        members.push_back(ood);
      }

      // FIXME: Source range isn't totally accurate because Clang lacks the
      // location of the '{'.
      result->setMembers(Impl.SwiftContext.AllocateCopy(members),
                         Impl.importSourceRange(clang::SourceRange(
                                                  decl->getLocation(),
                                                  decl->getRBraceLoc())));

      return result;
    }

    Decl *VisitRecordDecl(clang::RecordDecl *decl) {
      // FIXME: Skip unions for now. We can't properly map them to oneofs,
      // because they aren't descriminated in any way. We could map them to
      // structs, but that would make them very, very unsafe to use.
      if (decl->isUnion())
        return nullptr;

      // FIXME: Skip Microsoft __interfaces.
      if (decl->isInterface())
        return nullptr;

      // The types of anonymous structs or unions are never imported; their
      // fields are dumped directly into the enclosing class.
      if (decl->isAnonymousStructOrUnion())
        return nullptr;

      // FIXME: Figure out how to deal with incomplete types, since that
      // notion doesn't exist in Swift.
      decl = decl->getDefinition();
      if (!decl)
        return nullptr;

      Identifier name;
      if (decl->getDeclName())
        name = Impl.importName(decl->getDeclName());
      else if (decl->getTypedefNameForAnonDecl())
        name =Impl.importName(decl->getTypedefNameForAnonDecl()->getDeclName());

      if (name.empty())
        return nullptr;

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      // Create the struct declaration and record it.
      auto result = new (Impl.SwiftContext)
                      StructDecl(Impl.importSourceLoc(decl->getLocStart()),
                                 name,
                                 Impl.importSourceLoc(decl->getLocation()),
                                 { }, nullptr, dc);
      Impl.ImportedDecls[decl->getCanonicalDecl()] = result;

      // FIXME: Figure out what to do with base classes in C++. One possible
      // solution would be to turn them into members and add conversion
      // functions.

      // Import each of the members.
      SmallVector<Decl *, 4> members;
      for (auto m = decl->decls_begin(), mEnd = decl->decls_end();
           m != mEnd; ++m) {
        auto nd = dyn_cast<clang::NamedDecl>(*m);
        if (!nd)
          continue;

        // Skip anonymous structs or unions; they'll be dealt with via the
        // IndirectFieldDecls.
        if (auto field = dyn_cast<clang::FieldDecl>(nd))
          if (field->isAnonymousStructOrUnion())
            continue;

        auto member = Impl.importDecl(nd);
        if (!member)
          continue;

        members.push_back(member);
      }

      // FIXME: Source range isn't totally accurate because Clang lacks the
      // location of the '{'.
      result->setMembers(Impl.SwiftContext.AllocateCopy(members),
                         Impl.importSourceRange(clang::SourceRange(
                                                  decl->getLocation(),
                                                  decl->getRBraceLoc())));

      return result;
    }

    Decl *VisitClassTemplateSpecializationDecl(
                 clang::ClassTemplateSpecializationDecl *decl) {
      // FIXME: We could import specializations, but perhaps only as unnamed
      // structural types.
      return nullptr;
    }

    Decl *VisitClassTemplatePartialSpecializationDecl(
                 clang::ClassTemplatePartialSpecializationDecl *decl) {
      // Note: templates are not imported.
      return nullptr;
    }

    Decl *VisitTemplateTypeParmDecl(clang::TemplateTypeParmDecl *decl) {
      // Note: templates are not imported.
      return nullptr;
    }

    Decl *VisitEnumConstantDecl(clang::EnumConstantDecl *decl) {
      auto name = Impl.importName(decl->getDeclName());
      if (name.empty())
        return nullptr;

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      auto result
        = new (Impl.SwiftContext)
            OneOfElementDecl(Impl.importSourceLoc(decl->getLocation()),
                             name, TypeLoc(), dc);

      // Give the oneof element the appropriate type.
      auto oneof = cast<OneOfDecl>(dc);
      auto argTy = MetaTypeType::get(oneof->getDeclaredType(),
                                     Impl.SwiftContext);
      result->overwriteType(FunctionType::get(argTy, oneof->getDeclaredType(),
                                              Impl.SwiftContext));
      return result;
    }

    Decl *
    VisitUnresolvedUsingValueDecl(clang::UnresolvedUsingValueDecl *decl) {
      // Note: templates are not imported.
      return nullptr;
    }

    Decl *VisitIndirectFieldDecl(clang::IndirectFieldDecl *decl) {
      // Check whether the context of any of the fields in the chain is a
      // union. If so, don't import this field.
      for (auto f = decl->chain_begin(), fEnd = decl->chain_end(); f != fEnd;
           ++f) {
        if (auto record = dyn_cast<clang::RecordDecl>((*f)->getDeclContext())) {
          if (record->isUnion())
            return nullptr;
        }
      }

      auto name = Impl.importName(decl->getDeclName());
      if (name.empty())
        return nullptr;

      auto type = Impl.importType(decl->getType());
      if (!type)
        return nullptr;

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      // Map this indirect field to a Swift variable.
      return new (Impl.SwiftContext)
               VarDecl(Impl.importSourceLoc(decl->getLocStart()),
                       name, type, dc);
    }

    /// \brief Set the declaration context of each variable within the given
    /// patterns to \p dc.
    static void setVarDeclContexts(ArrayRef<Pattern *> patterns,
                                   DeclContext *dc) {
      for (auto pattern : patterns) {
        auto pat = pattern->getSemanticsProvidingPattern();
        if (auto named = dyn_cast<NamedPattern>(pat))
          named->getDecl()->setDeclContext(dc);
        if (auto tuple = dyn_cast<TuplePattern>(pat)) {
          for (auto elt : tuple->getFields())
            setVarDeclContexts(elt.getPattern(), dc);
        }
      }
    }

    Decl *VisitFunctionDecl(clang::FunctionDecl *decl) {
      // FIXME: We can't IRgen inline functions, so don't import them.
      if (decl->isInlined() || decl->hasAttr<clang::AlwaysInlineAttr>()) {
        return nullptr;
      }

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      // Import the function type. If we have parameters, make sure their names
      // get into the resulting function type.
      SmallVector<Pattern *, 4> argPatterns;
      SmallVector<Pattern *, 4> bodyPatterns;
      Type type;
      if (decl->param_size())
        type = Impl.importFunctionType(
                 decl->getType()->getAs<clang::FunctionType>()->getResultType(),
                 { decl->param_begin(), decl->param_size() },
                 decl->isVariadic(), argPatterns, bodyPatterns);
      else
        type = Impl.importType(decl->getType());

      if (!type)
        return nullptr;

      auto resultTy = type->castTo<FunctionType>()->getResult();
      auto loc = Impl.importSourceLoc(decl->getLocation());

      auto name = Impl.importName(decl->getDeclName());
      if (name.empty())
        return nullptr;

      // FIXME: Poor location info.
      auto funcExpr = FuncExpr::create(Impl.SwiftContext, loc,
                                       argPatterns, bodyPatterns,
                                       TypeLoc(resultTy, loc),
                                       nullptr, dc);
      funcExpr->setType(type);
      auto nameLoc = Impl.importSourceLoc(decl->getLocation());
      auto result = new (Impl.SwiftContext) FuncDecl(SourceLoc(), loc,
                                                     name, nameLoc,
                                                     /*GenericParams=*/0,
                                                     type, funcExpr,
                                                     dc);
      setVarDeclContexts(argPatterns, funcExpr);
      setVarDeclContexts(bodyPatterns, funcExpr);
      return result;
    }

    Decl *VisitCXXMethodDecl(clang::CXXMethodDecl *decl) {
      // FIXME: Import C++ member functions as methods.
      return nullptr;
    }

    Decl *VisitFieldDecl(clang::FieldDecl *decl) {
      // Fields are imported as variables.
      auto name = Impl.importName(decl->getDeclName());
      if (name.empty())
        return nullptr;

      auto type = Impl.importType(decl->getType());
      if (!type)
        return nullptr;

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      auto result = new (Impl.SwiftContext)
                      VarDecl(Impl.importSourceLoc(decl->getLocation()),
                              name, type, dc);

      // Handle attributes.
      if (decl->hasAttr<clang::IBOutletAttr>())
        result->getMutableAttrs().IBOutlet = true;
      // FIXME: Handle IBOutletCollection.

      return result;
    }

    Decl *VisitObjCIvarDecl(clang::ObjCIvarDecl *decl) {
      // FIXME: Deal with fact that a property and an ivar can have the same
      // name.
      return VisitFieldDecl(decl);
    }

    Decl *VisitObjCAtDefsFieldDecl(clang::ObjCAtDefsFieldDecl *decl) {
      // @defs is an anachronism; ignore it.
      return nullptr;
    }

    Decl *VisitVarDecl(clang::VarDecl *decl) {
      // FIXME: Swift does not have static variables in structs/classes yet.
      if (decl->getDeclContext()->isRecord())
        return nullptr;

      // Variables are imported as... variables.
      auto name = Impl.importName(decl->getDeclName());
      if (name.empty())
        return nullptr;

      auto type = Impl.importType(decl->getType());
      if (!type)
        return nullptr;

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      return new (Impl.SwiftContext)
               VarDecl(Impl.importSourceLoc(decl->getLocation()),
                       name, type, dc);
    }

    Decl *VisitImplicitParamDecl(clang::ImplicitParamDecl *decl) {
      // Parameters are never directly imported.
      return nullptr;
    }

    Decl *VisitParmVarDecl(clang::ParmVarDecl *decl) {
      // Parameters are never directly imported.
      return nullptr;
    }

    Decl *
    VisitNonTypeTemplateParmDecl(clang::NonTypeTemplateParmDecl *decl) {
      // Note: templates are not imported.
      return nullptr;
    }

    Decl *VisitTemplateDecl(clang::TemplateDecl *decl) {
      // Note: templates are not imported.
      return nullptr;
    }

    Decl *VisitUsingDecl(clang::UsingDecl *decl) {
      // Using declarations are not imported.
      return nullptr;
    }

    Decl *VisitUsingShadowDecl(clang::UsingShadowDecl *decl) {
      // Using shadow declarations are not imported; rather, name lookup just
      // looks through them.
      return nullptr;
    }

    Decl *VisitObjCMethodDecl(clang::ObjCMethodDecl *decl) {
      auto loc = Impl.importSourceLoc(decl->getLocStart());
      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      // The name of the method is the first part of the selector.
      auto name
        = Impl.importName(decl->getSelector().getIdentifierInfoForSlot(0));
      if (name.empty())
        return nullptr;

      // Figure out the type of the container.
      auto containerTy = dc->getDeclaredTypeOfContext();
      assert(containerTy && "Method in non-type context?");

      // Add the implicit 'this' parameter patterns.
      SmallVector<Pattern *, 4> argPatterns;
      SmallVector<Pattern *, 4> bodyPatterns;
      auto thisTy = containerTy;
      if (decl->isClassMethod())
        thisTy = MetaTypeType::get(thisTy, Impl.SwiftContext);
      auto thisName = Impl.SwiftContext.getIdentifier("this");
      auto thisVar = new (Impl.SwiftContext) VarDecl(SourceLoc(), thisName,
                                                     thisTy,
                                                     Impl.firstClangModule);
      Pattern *thisPat = new (Impl.SwiftContext) NamedPattern(thisVar);
      thisPat->setType(thisVar->getType());
      thisPat
        = new (Impl.SwiftContext) TypedPattern(thisPat,
                                               TypeLoc(thisTy, loc));
      thisPat->setType(thisVar->getType());
      argPatterns.push_back(thisPat);
      bodyPatterns.push_back(thisPat);
      
      // Import the type that this method will have.
      auto type = Impl.importFunctionType(decl->getResultType(),
                                          { decl->param_begin(),
                                            decl->param_size() },
                                          decl->isVariadic(),
                                          argPatterns,
                                          bodyPatterns,
                                          decl->getSelector());
      if (!type)
        return nullptr;

      auto resultTy = type->castTo<FunctionType>()->getResult();

      // Add the 'this' parameter to the function type.
      type = FunctionType::get(thisTy, type, Impl.SwiftContext);

      // FIXME: Related result type? Not so important when we get constructors
      // working.

      // FIXME: Poor location info.
      auto nameLoc = Impl.importSourceLoc(decl->getLocation());
      auto funcExpr = FuncExpr::create(Impl.SwiftContext, loc,
                                       argPatterns, bodyPatterns,
                                       TypeLoc(resultTy, loc),
                                       nullptr, dc);
      funcExpr->setType(type);

      auto result = new (Impl.SwiftContext) FuncDecl(SourceLoc(), loc,
                                                     name, nameLoc,
                                                     /*GenericParams=*/0,
                                                     type, funcExpr, dc);

      setVarDeclContexts(argPatterns, funcExpr);
      setVarDeclContexts(bodyPatterns, funcExpr);

      // Mark this as an Objective-C method.
      result->getMutableAttrs().ObjC = true;

      // Mark class methods as static.
      if (decl->isClassMethod())
        result->setStatic();

      // If this method overrides another method, mark it as such.
      // FIXME: We'll eventually have to deal with having multiple overrides
      // in Swift.
      if (decl->isOverriding()) {
        SmallVector<const clang::ObjCMethodDecl *, 2> overridden;
        decl->getOverriddenMethods(overridden);
        clang::ObjCMethodDecl *superResult = nullptr;
        clang::ObjCMethodDecl *categoryResult = nullptr;
        for (auto ov : overridden) {
          if (isa<clang::ObjCInterfaceDecl>(ov->getDeclContext()))
            superResult = const_cast<clang::ObjCMethodDecl *>(ov);
          else if (isa<clang::ObjCCategoryDecl>(ov->getDeclContext()))
            categoryResult = const_cast<clang::ObjCMethodDecl *>(ov);
        }

        if (superResult)
          result->setOverriddenDecl(
            cast_or_null<FuncDecl>(Impl.importDecl(superResult)));
        else if (categoryResult)
          result->setOverriddenDecl(
            cast_or_null<FuncDecl>(Impl.importDecl(categoryResult)));
      }

      // Handle attributes.
      if (decl->hasAttr<clang::IBActionAttr>())
        result->getMutableAttrs().IBAction = true;

      return result;
    }

  private:
    /// \brief Given an imported method, try to import it as some kind of
    /// special declaration, e.g., a constructor or subscript.
    Decl *importSpecialMethod(Decl *decl) {
      // Only consider Objective-C methods...
      auto objcMethod
        = dyn_cast_or_null<clang::ObjCMethodDecl>(decl->getClangDecl());
      if (!objcMethod)
        return nullptr;

      switch (objcMethod->getMethodFamily()) {
      case clang::OMF_None:
        // Check for one of the subscripting selectors.
        if (objcMethod->isInstanceMethod() &&
            (objcMethod->getSelector() == Impl.objectAtIndexedSubscript ||
             objcMethod->getSelector() == Impl.setObjectAtIndexedSubscript ||
             objcMethod->getSelector() == Impl.objectForKeyedSubscript ||
             objcMethod->getSelector() == Impl.setObjectForKeyedSubscript))
          return importSubscript(decl, objcMethod);
          
        return nullptr;

      case clang::OMF_new:
      case clang::OMF_alloc:
      case clang::OMF_autorelease:
      case clang::OMF_copy:
      case clang::OMF_dealloc:
      case clang::OMF_finalize:
      case clang::OMF_mutableCopy:
      case clang::OMF_performSelector:
      case clang::OMF_release:
      case clang::OMF_retain:
      case clang::OMF_retainCount:
      case clang::OMF_self:
        // None of these methods have special consideration.
        return nullptr;

      case clang::OMF_init:
        // An init instance method can be a constructor.
        if (objcMethod->isInstanceMethod())
          return importConstructor(decl, objcMethod);
        return nullptr;
      }
    }

    /// \brief Given an imported method, try to import it as a constructor.
    ///
    /// Objective-C methods in the 'init' and 'new' family are imported as
    /// constructors in Swift, enabling the 'new' syntax, e.g.,
    ///
    /// \code
    /// new NSArray(1024) // same as NSArray.alloc.initWithCapacity:1024
    /// \endcode
    ConstructorDecl *importConstructor(Decl *decl,
                                       clang::ObjCMethodDecl *objcMethod) {
      // Figure out the type of the container.
      auto dc = decl->getDeclContext();
      auto containerTy = dc->getDeclaredTypeOfContext();
      assert(containerTy && "Method in non-type context?");

      // Make sure that NSObject is a supertype of the container.
      // FIXME: This is a hack because we don't have a suitable 'top' type for
      // Objective-C classes.
      auto checkTy = containerTy;
      do {
        auto classDecl = checkTy->getClassOrBoundGenericClass();
        if (!classDecl) {
          return nullptr;
        }

        if (classDecl->getName().str() == "NSObject")
          break;

        checkTy = classDecl->getBaseClass();
        if (!checkTy)
          return nullptr;
      } while (true);

      // Only methods in the 'init' and 'new' family can become constructors.
      FuncDecl *alloc = nullptr;
      switch (objcMethod->getMethodFamily()) {
      case clang::OMF_alloc:
      case clang::OMF_autorelease:
      case clang::OMF_copy:
      case clang::OMF_dealloc:
      case clang::OMF_finalize:
      case clang::OMF_mutableCopy:
      case clang::OMF_None:
      case clang::OMF_performSelector:
      case clang::OMF_release:
      case clang::OMF_retain:
      case clang::OMF_retainCount:
      case clang::OMF_self:
        llvm_unreachable("Caller did not filter non-constructor methods");

      case clang::OMF_init: {
        // Make sure we have a usable 'alloc' method. Otherwise, we can't
        // build this constructor anyway.
        // FIXME: Can we do this for protocol methods as well? Do we want to?
        auto interface = objcMethod->getClassInterface();
        if (!interface)
          return nullptr;

        // Form the Objective-C selector for alloc.
        auto &clangContext = Impl.getClangASTContext();
        auto allocId = &clangContext.Idents.get("alloc");
        auto allocSel = clangContext.Selectors.getNullarySelector(allocId);

        // Find the 'alloc' class method.
        auto allocMethod = interface->lookupClassMethod(allocSel);
        if (!allocMethod)
          return nullptr;

        // Import the 'alloc' class method.
        alloc = cast_or_null<FuncDecl>(Impl.importDecl(allocMethod));
        if (!alloc)
          return nullptr;
        break;
      }

      case clang::OMF_new:
        assert(objcMethod->isClassMethod() && "Caller did not filter inputs");
        break;
      }

      // FIXME: Hack.
      auto loc = decl->getLoc();
      auto name = Impl.SwiftContext.getIdentifier("constructor");

      // Add the implicit 'this' parameter patterns.
      SmallVector<Pattern *, 4> argPatterns;
      SmallVector<Pattern *, 4> bodyPatterns;
      auto thisTy = containerTy;
      auto thisMetaTy = MetaTypeType::get(containerTy, Impl.SwiftContext);
      auto thisName = Impl.SwiftContext.getIdentifier("this");
      auto thisMetaVar = new (Impl.SwiftContext) VarDecl(SourceLoc(), thisName,
                                                         thisMetaTy,
                                                         Impl.firstClangModule);
      Pattern *thisPat = new (Impl.SwiftContext) NamedPattern(thisMetaVar);
      thisPat->setType(thisMetaTy);
      thisPat
        = new (Impl.SwiftContext) TypedPattern(thisPat,
                                               TypeLoc(thisMetaTy, loc));
      thisPat->setType(thisMetaTy);

      argPatterns.push_back(thisPat);
      bodyPatterns.push_back(thisPat);

      // Import the type that this method will have.
      auto type = Impl.importFunctionType(objcMethod->getResultType(),
                                          { objcMethod->param_begin(),
                                            objcMethod->param_size() },
                                          objcMethod->isVariadic(),
                                          argPatterns,
                                          bodyPatterns,
                                          objcMethod->getSelector(),
                                          /*isConstructor=*/true);
      assert(type && "Type has already been successfully converted?");

      // A constructor returns an object of the type, not 'id'.
      // This is effectively implementing related-result-type semantics.
      // FIXME: Perhaps actually check whether the routine has a related result
      // type?
      type = FunctionType::get(type->castTo<FunctionType>()->getInput(),
                               thisTy, Impl.SwiftContext);

      // Add the 'this' parameter to the function type.
      type = FunctionType::get(thisMetaTy, type, Impl.SwiftContext);

      VarDecl *thisVar = new (Impl.SwiftContext) VarDecl(SourceLoc(),
                                                          thisName, thisTy, dc);

      // Create the actual constructor.
      // FIXME: Losing body patterns here.
      auto result = new (Impl.SwiftContext) ConstructorDecl(name, loc,
                                                            argPatterns.back(),
                                                            thisVar,
                                                            /*GenericParams=*/0,
                                                            dc);
      result->getMutableAttrs().AllocatesThis = true;
      result->setType(type);
      thisVar->setDeclContext(result);
      setVarDeclContexts(argPatterns, result);
      setVarDeclContexts(bodyPatterns, result);

      // Create the body of the constructor, which will call the appropriate
      // underlying method (and 'alloc', if needed).
      // FIXME: Use the 'this' of metaclass type rather than a metatype
      // expression.
      Expr* initExpr = new (Impl.SwiftContext) MetatypeExpr(nullptr, loc,
                                                            thisMetaTy);

      if (objcMethod->getMethodFamily() == clang::OMF_init) {
        // For an 'init' method, we need to call alloc first.
        Expr *allocRef
          = new (Impl.SwiftContext) DeclRefExpr(alloc, loc,
                                                alloc->getTypeOfReference());

        auto allocCall = new (Impl.SwiftContext) DotSyntaxCallExpr(allocRef,
                                                                   loc,
                                                                   initExpr);
        auto emptyTuple = new (Impl.SwiftContext) TupleExpr(loc, {}, nullptr,
                                                            loc);
        initExpr = new (Impl.SwiftContext) CallExpr(allocCall, emptyTuple);

        // Cast the result of the alloc call to the (metatype) 'this'.
        auto toTypeRef = new (Impl.SwiftContext) MetatypeExpr(nullptr, loc,
                                                              thisMetaTy);
        initExpr = new (Impl.SwiftContext) CallExpr(toTypeRef, initExpr);
      }

      // Form a reference to the actual method.
      auto func = cast<FuncDecl>(decl);
      auto funcRef
        = new (Impl.SwiftContext) DeclRefExpr(func, loc,
                                              func->getTypeOfReference());
      initExpr = new (Impl.SwiftContext) DotSyntaxCallExpr(funcRef, loc,
                                                           initExpr);

      // Form the call arguments.
      SmallVector<Expr *, 2> callArgs;
      auto tuple = dyn_cast<TuplePattern>(argPatterns[1]);
      if (!tuple) {
        // FIXME: We don't want this to be the case. We should always ensure
        // that the body has names, even if the interface does not.
        return nullptr;
      }

      for (auto elt : tuple->getFields()) {
        auto named = dyn_cast<NamedPattern>(
                       elt.getPattern()->getSemanticsProvidingPattern());
        if (!named) {
          // FIXME: We don't want this to be the case. Can we fake up names
          // in the body parameters so this doesn't happen?
          return nullptr;
        }

        // Create a reference to this parameter.
        Expr *ref = new (Impl.SwiftContext) DeclRefExpr(named->getDecl(),
                                                        loc,
                                                        named->getType());

        // If the parameter is [byref], take its address.
        if (named->getDecl()->getType()->is<LValueType>())
          ref = new (Impl.SwiftContext) AddressOfExpr(loc, ref,
                                                      ref->getType());

        callArgs.push_back(ref);
      }

      // Form the method call.
      Expr *callArg;

      if (callArgs.size() == 1) {
        callArg = callArgs[0];
      } else {
        auto callArgsCopy = Impl.SwiftContext.AllocateCopy(callArgs);
        callArg = new (Impl.SwiftContext) TupleExpr(loc, callArgsCopy,
                                                    nullptr, loc);
      }

      initExpr = new (Impl.SwiftContext) CallExpr(initExpr, callArg);

      // Cast the result of the alloc call to the (metatype) 'this'.
      auto toTypeRef = new (Impl.SwiftContext) MetatypeExpr(nullptr, loc,
                                                            thisMetaTy);
      initExpr = new (Impl.SwiftContext) CallExpr(toTypeRef, initExpr);

      // Form the assignment statement.
      auto refThis
        = new (Impl.SwiftContext) DeclRefExpr(thisVar, loc,
                                              thisVar->getTypeOfReference());
      auto assign = new (Impl.SwiftContext) AssignStmt(refThis, loc, initExpr);

      // Set the body of the constructor.
      result->setBody(BraceStmt::create(Impl.SwiftContext, loc,
                                        BraceStmt::ExprStmtOrDecl(assign),
                                        loc));

      // Inform the context that we have external definitions.
      Impl.firstClangModule->addExternalDefinition(result);
      
      return result;
    }

    /// \brief Retrieve the single variable described in the given pattern.
    ///
    /// This routine assumes that the pattern is something very simple
    /// like (x : type) or (x).
    VarDecl *getSingleVar(Pattern *pattern) {
      pattern = pattern->getSemanticsProvidingPattern();
      if (auto tuple = dyn_cast<TuplePattern>(pattern)) {
        pattern = tuple->getFields()[0].getPattern()
                    ->getSemanticsProvidingPattern();
      }

      return cast<NamedPattern>(pattern)->getDecl();
    }

    /// \brief Add the implicit 'this' pattern to the given list of patterns.
    ///
    /// \param thisTy The type of the 'this' parameter.
    ///
    /// \param args The set of arguments 
    VarDecl *addImplicitThisParameter(Type thisTy,
                                      SmallVectorImpl<Pattern *> &args) {
      auto thisName = Impl.SwiftContext.getIdentifier("this");
      auto thisVar = new (Impl.SwiftContext) VarDecl(SourceLoc(), thisName,
                                                     thisTy,
                                                     Impl.firstClangModule);
      Pattern *thisPat = new (Impl.SwiftContext) NamedPattern(thisVar);
      thisPat->setType(thisVar->getType());
      thisPat = new (Impl.SwiftContext) TypedPattern(
                                          thisPat,
                                          TypeLoc::withoutLoc(thisTy));
      thisPat->setType(thisVar->getType());
      args.push_back(thisPat);

      return thisVar;
    }

    /// \brief Build a thunk for an Objective-C getter.
    ///
    /// \param getter The Objective-C getter method.
    ///
    /// \param dc The declaration context into which the thunk will be added.
    ///
    /// \param indices If non-null, the indices for a subscript getter. Null
    /// indicates that we're generating a getter thunk for a property getter.
    ///
    /// \returns The getter thunk.
    FuncDecl *buildGetterThunk(FuncDecl *getter, DeclContext *dc,
                               Pattern *indices) {
      auto &context = Impl.SwiftContext;
      auto loc = getter->getLoc();

      // Figure out the element type, by looking through 'this' and the normal
      // parameters.
      auto elementTy
        = getter->getType()->castTo<FunctionType>()->getResult()
            ->castTo<FunctionType>()->getResult();

      // Form the argument patterns.
      SmallVector<Pattern *, 3> getterArgs;

      // 'this'
      auto thisVar = addImplicitThisParameter(dc->getDeclaredTypeOfContext(),
                                              getterArgs);

      // index, for subscript operations.
      if (indices) {
        // Clone the indices for the thunk.
        indices = indices->clone(context);
        auto pat = TuplePattern::create(context, loc, TuplePatternElt(indices),
                                        loc);
        pat->setType(TupleType::get(TupleTypeElt(indices->getType(),
                                                 indices->getBoundName()),
                                    context));
        getterArgs.push_back(pat);
      }

      // empty tuple
      getterArgs.push_back(TuplePattern::create(context, loc, { }, loc));
      getterArgs.back()->setType(TupleType::getEmpty(context));

      // Form the type of the getter.
      auto getterType = elementTy;
      for (auto it = getterArgs.rbegin(), itEnd = getterArgs.rend();
           it != itEnd; ++it) {
        getterType = FunctionType::get((*it)->getType(),
                                       getterType,
                                       context);
      }

      // Create the getter body.
      auto funcExpr = FuncExpr::create(context, getter->getLoc(),
                                       getterArgs,
                                       getterArgs,
                                       TypeLoc(elementTy, loc),
                                       nullptr,
                                       getter->getDeclContext());
      funcExpr->setType(getterType);
      setVarDeclContexts(getterArgs, funcExpr);

      // Create the getter thunk.
      auto thunk = new (context) FuncDecl(SourceLoc(), getter->getLoc(),
                                          Identifier(), SourceLoc(), nullptr,
                                          getterType, funcExpr,
                                          getter->getDeclContext());

      // Create the body of the thunk, which calls the Objective-C getter.
      auto thisRef = new (context) DeclRefExpr(thisVar, loc,
                                               thisVar->getTypeOfReference());
      auto getterRef
        = new (context) DeclRefExpr(getter, loc,
                                    getter->getTypeOfReference());

      // First, bind 'this' to the method.
      Expr *call = new (context) DotSyntaxCallExpr(getterRef, loc, thisRef);

      // Call the method itself.
      if (indices) {
        // For a subscript, pass the index.
        auto indexVar = getSingleVar(getterArgs[1]);
        auto indexRef
          = new (context) DeclRefExpr(indexVar, loc,
                                      indexVar->getTypeOfReference());
        call = new (context) CallExpr(call, indexRef);
      } else {
        // For a property, call with no arguments.
        auto emptyTuple = new (context) TupleExpr(loc, { }, nullptr, loc);
        call = new (context) CallExpr(call, emptyTuple);
      }

      // Create the return statement.
      auto ret = new (context) ReturnStmt(loc, call);

      // Finally, set the body.
      funcExpr->setBody(BraceStmt::create(context, loc,
                                          BraceStmt::ExprStmtOrDecl(ret),
                                          loc));

      // Register this thunk as an external definition.
      Impl.firstClangModule->addExternalDefinition(thunk);
      
      return thunk;
    }

    /// \brief Build a thunk for an Objective-C setter.
    ///
    /// \param setter The Objective-C setter method.
    ///
    /// \param dc The declaration context into which the thunk will be added.
    ///
    /// \param indices If non-null, the indices for a subscript setter. Null
    /// indicates that we're generating a setter thunk for a property setter.
    ///
    /// \returns The getter thunk.
    FuncDecl *buildSetterThunk(FuncDecl *setter, DeclContext *dc,
                               Pattern *indices) {
      auto &context = Impl.SwiftContext;
      auto loc = setter->getLoc();
      auto tuple = cast<TuplePattern>(
                     setter->getBody()->getBodyParamPatterns()[1]);

      // Objective-C subscript setters are imported with a function type
      // such as:
      //
      //   (this) -> (value, index) -> ()
      //
      // while Swift subscript setters are curried as
      //
      //   (this) -> (index)(value) -> ()
      //
      // Build a setter thunk with the latter signature that maps to the
      // former.
      //
      // Property setters are similar, but don't have indices.

      // Form the argument patterns.
      llvm::SmallVector<Pattern *, 3> setterArgs;

      // 'this'
      auto thisVar = addImplicitThisParameter(dc->getDeclaredTypeOfContext(),
                                              setterArgs);

      // index, for subscript operations.
      if (indices) {
        // Clone the indices for the thunk.
        indices = indices->clone(context);
        auto pat = TuplePattern::create(context, loc, TuplePatternElt(indices),
                                        loc);
        pat->setType(TupleType::get(TupleTypeElt(indices->getType(),
                                                 indices->getBoundName()),
                                    context));
        setterArgs.push_back(pat);
      }

      // value
      auto valuePattern = tuple->getFields()[0].getPattern()->clone(context);
      setterArgs.push_back(TuplePattern::create(context, loc,
                                                TuplePatternElt(valuePattern),
                                                loc));
      setterArgs.back()->setType(
        TupleType::get(TupleTypeElt(valuePattern->getType(),
                                    valuePattern->getBoundName()),
                       context));

      // Form the type of the setter.
      auto setterType = TupleType::getEmpty(context);
      for (auto it = setterArgs.rbegin(), itEnd = setterArgs.rend();
           it != itEnd; ++it) {
        setterType = FunctionType::get((*it)->getType(),
                                       setterType,
                                       context);
      }


      // Create the setter body.
      auto funcExpr = FuncExpr::create(context, setter->getLoc(),
                                       setterArgs,
                                       setterArgs,
                                       TypeLoc(TupleType::getEmpty(context),
                                               loc),
                                       nullptr,
                                       setter->getDeclContext());
      funcExpr->setType(setterType);
      setVarDeclContexts(setterArgs, funcExpr);

      // Create the setter thunk.
      auto thunk = new (context) FuncDecl(SourceLoc(), setter->getLoc(),
                                          Identifier(), SourceLoc(), nullptr,
                                          setterType, funcExpr, dc);

      // Create the body of the thunk, which calls the Objective-C setter.
      auto valueVar = getSingleVar(setterArgs.back());

      auto thisRef = new (context) DeclRefExpr(thisVar, loc,
                                               thisVar->getTypeOfReference());
      auto valueRef
        = new (context) DeclRefExpr(valueVar, loc,
                                    valueVar->getTypeOfReference());
      auto setterRef
        = new (context) DeclRefExpr(setter, loc,
                                    setter->getTypeOfReference());

      // First, bind 'this' to the method.
      Expr *call = new (context) DotSyntaxCallExpr(setterRef, loc, thisRef);

      // Next, call the Objective-C setter.
      Expr *callArgs;
      if (indices) {
        // For subscript setters, we have both value and index.
        auto indexVar = getSingleVar(setterArgs[1]);
        auto indexRef
          = new (context) DeclRefExpr(indexVar, loc,
                                      indexVar->getTypeOfReference());

        Expr *callArgsArray[2] = { valueRef, indexRef };
        callArgs
          = new (context) TupleExpr(loc,
                                    context.AllocateCopy(
                                      MutableArrayRef<Expr*>(callArgsArray)),
                                  nullptr, loc);
      } else {
        callArgs = valueRef;
      }
      call = new (context) CallExpr(call, callArgs);

      // Finally, set the body.
      funcExpr->setBody(BraceStmt::create(context, loc,
                                          BraceStmt::ExprStmtOrDecl(call),
                                          loc));

      // Register this thunk as an external definition.
      Impl.firstClangModule->addExternalDefinition(thunk);

      return thunk;
    }
    
    /// \brief Given either the getter or setter for a subscript operation,
    /// create the Swift subscript declaration.
    SubscriptDecl *importSubscript(Decl *decl,
                                   clang::ObjCMethodDecl *objcMethod) {
      assert(objcMethod->isInstanceMethod() && "Caller must filter");

      // Make sure we have a usable 'alloc' method. Otherwise, we can't
      // build this constructor anyway.
      // FIXME: Can we do this for protocol methods as well? Do we want to?
      auto interface = objcMethod->getClassInterface();
      if (!interface)
        return nullptr;

      FuncDecl *getter = nullptr, *setter = nullptr;
      if (objcMethod->getSelector() == Impl.objectAtIndexedSubscript) {
        getter = cast<FuncDecl>(decl);

        // Find the setter
        if (auto objcSetter = interface->lookupInstanceMethod(
                                Impl.setObjectAtIndexedSubscript)) {
          setter = cast_or_null<FuncDecl>(Impl.importDecl(objcSetter));

          // Don't allow static setters.
          if (setter && setter->isStatic())
            setter = nullptr;
        }
      } else if (objcMethod->getSelector() == Impl.setObjectAtIndexedSubscript){
        setter = cast<FuncDecl>(decl);

        // Find the getter.
        if (auto objcGetter = interface->lookupInstanceMethod(
                                Impl.objectAtIndexedSubscript)) {
          getter = cast_or_null<FuncDecl>(Impl.importDecl(objcGetter));

          // Don't allow static getters.
          if (getter && getter->isStatic())
            return nullptr;
        }

        // FIXME: Swift doesn't have write-only subscripting.
        if (!getter)
          return nullptr;
      } else if (objcMethod->getSelector() == Impl.objectForKeyedSubscript) {
        getter = cast<FuncDecl>(decl);

        // Find the setter
        if (auto objcSetter = interface->lookupInstanceMethod(
                                Impl.setObjectForKeyedSubscript)) {
          setter = cast_or_null<FuncDecl>(Impl.importDecl(objcSetter));

          // Don't allow static setters.
          if (setter && setter->isStatic())
            setter = nullptr;
        }
      } else if (objcMethod->getSelector() == Impl.setObjectForKeyedSubscript) {
        setter = cast<FuncDecl>(decl);

        // Find the getter.
        if (auto objcGetter = interface->lookupInstanceMethod(
                                Impl.objectForKeyedSubscript)) {
          getter = cast_or_null<FuncDecl>(Impl.importDecl(objcGetter));

          // Don't allow static getters.
          if (getter && getter->isStatic())
            return nullptr;
        }

        // FIXME: Swift doesn't have write-only subscripting.
        if (!getter)
          return nullptr;

      } else {
        llvm_unreachable("Unknown getter/setter selector");
      }

      // Check whether we've already created a subscript operation for
      // this getter/setter pair.
      if (Impl.Subscripts[{getter, setter}])
        return nullptr;

      // Compute the element type, looking through the implicit 'this'
      // parameter and the normal function parameters.
      auto elementTy
        = getter->getType()->castTo<AnyFunctionType>()->getResult()
            ->castTo<AnyFunctionType>()->getResult();

      // Check the form of the getter.
      auto dc = decl->getDeclContext();
      FuncDecl *getterThunk = nullptr;
      auto &context = Impl.SwiftContext;
      {
        auto tuple = dyn_cast<TuplePattern>(
                       getter->getBody()->getArgParamPatterns()[1]);
        if (tuple && tuple->getFields().size() != 1)
          return nullptr;

        auto indices = tuple->getFields()[0].getPattern();
        getterThunk = buildGetterThunk(getter, dc, indices);
      }

      // Check the form of the setter.
      FuncDecl *setterThunk = nullptr;
      if (setter) {
        auto tuple = dyn_cast<TuplePattern>(
                       setter->getBody()->getBodyParamPatterns()[1]);
        if (!tuple)
          return nullptr;

        if (tuple->getFields().size() != 2)
          return nullptr;

        // The setter must accept elements of the same type as the getter
        // returns.
        // FIXME: Adjust C++ references?
        auto setterElementTy = tuple->getFields()[0].getPattern()->getType();
        if (!elementTy->isEqual(setterElementTy))
          return nullptr;

        auto indices = tuple->getFields()[1].getPattern();
        setterThunk = buildSetterThunk(setter, dc, indices);
      }

      // Build the subscript declaration.
      auto loc = decl->getLoc();
      auto argPatterns
        = getterThunk->getBody()->getArgParamPatterns()[1]->clone(context);
      auto name = context.getIdentifier("__subscript");
      auto subscript
        = new (context) SubscriptDecl(name, decl->getLoc(), argPatterns,
                                      decl->getLoc(), TypeLoc(elementTy, loc),
                                      SourceRange(), getterThunk, setterThunk,
                                      dc);
      setVarDeclContexts(argPatterns, subscript->getDeclContext());

      subscript->setType(FunctionType::get(subscript->getIndices()->getType(),
                                           subscript->getElementType(),
                                           context));
      getterThunk->makeGetter(subscript);
      if (setterThunk)
        setterThunk->makeSetter(subscript);

      // Determine whether this subscript operation overrides another subscript
      // operation.
      // FIXME: This ends up looking in the superclass for entirely bogus
      // reasons. Fix it.
      auto containerTy = dc->getDeclaredTypeInContext();
      MemberLookup lookup(containerTy, name, *Impl.firstClangModule);
      Type unlabeledIndices;
      for (const auto &result : lookup.Results) {
        auto parentSub = dyn_cast<SubscriptDecl>(result.D);
        if (!parentSub)
          continue;

        // Compute the type of indices for our own subscript operation, lazily.
        if (!unlabeledIndices) {
          unlabeledIndices = subscript->getIndices()->getType()
                               ->getUnlabeledType(Impl.SwiftContext);
        }

        // Compute the type of indices for the subscript we found.
        auto parentUnlabeledIndices = parentSub->getIndices()->getType()
                                       ->getUnlabeledType(Impl.SwiftContext);
        if (!unlabeledIndices->isEqual(parentUnlabeledIndices))
          continue;

        // The index types match. This is an override, so mark it as such.
        subscript->setOverriddenDecl(parentSub);
        if (auto parentGetter = parentSub->getGetter()) {
          if (getterThunk)
              getterThunk->setOverriddenDecl(parentGetter);
        }
        if (auto parentSetter = parentSub->getSetter()) {
          if (setterThunk)
            setterThunk->setOverriddenDecl(parentSetter);
        }

        // FIXME: Eventually, deal with multiple overrides.
        break;
      }

      // Note that we've created this subscript.
      Impl.Subscripts[{getter, setter}] = subscript;
      return subscript;
    }

  public:
    Decl *VisitObjCCategoryDecl(clang::ObjCCategoryDecl *decl) {
      // Objective-C categories and extensions map to Swift extensions.

      // Find the Swift class being extended.
      auto objcClass
        = cast_or_null<ClassDecl>(Impl.importDecl(decl->getClassInterface()));
      if (!objcClass)
        return nullptr;

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      // FIXME: Import protocols, add them to 'inherited' list.
      
      // Create the extension declaration and record it.
      auto loc = Impl.importSourceLoc(decl->getLocStart());
      auto result
        = new (Impl.SwiftContext)
            ExtensionDecl(loc, TypeLoc(objcClass->getDeclaredType(), loc),
                          { }, dc);
      Impl.ImportedDecls[decl->getCanonicalDecl()] = result;

      // Import each of the members.
      SmallVector<Decl *, 4> members;
      for (auto m = decl->decls_begin(), mEnd = decl->decls_end();
           m != mEnd; ++m) {
        auto nd = dyn_cast<clang::NamedDecl>(*m);
        if (!nd)
          continue;

        auto member = Impl.importDecl(nd);
        if (!member)
          continue;

        // If this member is a method that is a getter or setter for a property
        // that was imported, don't add it to the list of members so it won't
        // be found by name lookup. This eliminates the ambiguity between
        // property names and getter names (by choosing to only have a
        // variable).
        if (auto objcMethod = dyn_cast<clang::ObjCMethodDecl>(nd)) {
          if (auto property = objcMethod->findPropertyDecl())
            if (Impl.importDecl(
                  const_cast<clang::ObjCPropertyDecl *>(property)))
              continue;

          // If there is a special declaration associated with this member,
          // add it now.
          if (auto special = importSpecialMethod(member)) {
            members.push_back(special);
          }
        }

        members.push_back(member);
      }

      // FIXME: Source range isn't accurate.
      result->setMembers(Impl.SwiftContext.AllocateCopy(members),
                         Impl.importSourceRange(clang::SourceRange(
                                                  decl->getLocation(),
                                                  decl->getLocEnd())));

      return result;
    }

    // FIXME: ObjCProtocolDecl

    Decl *VisitObjCInterfaceDecl(clang::ObjCInterfaceDecl *decl) {
      // FIXME: Figure out how to deal with incomplete types, since that
      // notion doesn't exist in Swift.
      decl = decl->getDefinition();
      if (!decl)
        return nullptr;

      auto name = Impl.importName(decl->getDeclName());
      if (name.empty())
        return nullptr;

      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      // FIXME: Import the protocols that this class conforms to. There's
      // a minor, annoying problem here because those protocols might mention
      // this class before we've had a chance to build it (due to forward
      // declarations). The same issue occurs with the superclass...

      // Create the class declaration and record it.
      auto result = new (Impl.SwiftContext)
                      ClassDecl(Impl.importSourceLoc(decl->getLocStart()),
                                name,
                                Impl.importSourceLoc(decl->getLocation()),
                                { }, nullptr, dc);
      Impl.ImportedDecls[decl->getCanonicalDecl()] = result;

      // If this Objective-C class has a supertype, import it.
      if (auto objcSuper = decl->getSuperClass()) {
        auto super = cast_or_null<ClassDecl>(Impl.importDecl(objcSuper));
        if (!super)
          return nullptr;

        TypeLoc superTy(super->getDeclaredType(),
                        Impl.importSourceRange(decl->getSuperClassLoc()));
        result->setBaseClassLoc(superTy);
      }

      // Note that this is an Objective-C class.
      result->getMutableAttrs().ObjC = true;
      
      // Import each of the members.
      SmallVector<Decl *, 4> members;
      for (auto m = decl->decls_begin(), mEnd = decl->decls_end();
           m != mEnd; ++m) {
        auto nd = dyn_cast<clang::NamedDecl>(*m);
        if (!nd)
          continue;

        auto member = Impl.importDecl(nd);
        if (!member)
          continue;

        // If this member is a method that is a getter or setter for a property
        // that was imported, don't add it to the list of members so it won't
        // be found by name lookup. This eliminates the ambiguity between
        // property names and getter names (by choosing to only have a
        // variable).
        if (auto objcMethod = dyn_cast<clang::ObjCMethodDecl>(nd)) {
          if (auto property = objcMethod->findPropertyDecl())
            if (Impl.importDecl(
                  const_cast<clang::ObjCPropertyDecl *>(property)))
              continue;

          // If there is a special declaration associated with this member,
          // add it now.
          if (auto special = importSpecialMethod(member)) {
            members.push_back(special);
          }
        }

        members.push_back(member);
      }

      // FIXME: Source range isn't accurate.
      result->setMembers(Impl.SwiftContext.AllocateCopy(members),
                         Impl.importSourceRange(clang::SourceRange(
                                                  decl->getLocation(),
                                                  decl->getLocEnd())));

      return result;
    }

    Decl *VisitObjCImplDecl(clang::ObjCImplDecl *decl) {
      // Implementations of Objective-C classes and categories are not
      // reflected into Swift.
      return nullptr;
    }

    /// \brief Given an untyped collection and an element type,
    /// produce the typed collection (if possible) or return the collection
    /// itself (if there is no known corresponding typed collection).
    Type getTypedCollection(Type collectionTy, Type elementTy) {
      auto classTy = collectionTy->getAs<ClassType>();
      if (!classTy) {
        return collectionTy;
      }
      
      // Map known collections to their typed equivalents.
      // FIXME: This is very hacky.
      typedef std::pair<StringRef, StringRef> StringRefPair;
      StringRefPair typedCollection
        = llvm::StringSwitch<StringRefPair>(classTy->getDecl()->getName().str())
            .Case("NSArray", StringRefPair("Foundation", "NSTypedArray"))
            .Default(StringRefPair(StringRef(), StringRef()));
      if (typedCollection.first.empty()) {
        return collectionTy;
      }

      // Form the specialization.
      if (auto typed = Impl.getNamedSwiftTypeSpecialization(
                         Impl.getNamedModule(typedCollection.first),
                         typedCollection.second,
                         elementTy)) {
        return typed;
      }

      return collectionTy;
    }

    Decl *VisitObjCPropertyDecl(clang::ObjCPropertyDecl *decl) {
      // Properties are imported as variables.
      auto dc = Impl.importDeclContext(decl->getDeclContext());
      if (!dc)
        return nullptr;

      auto name = Impl.importName(decl->getDeclName());
      if (name.empty())
        return nullptr;

      // Check whether there is a function with the same name as this
      // property. If so, suppress the property; the user will have to use
      // the methods directly, to avoid ambiguities.
      auto containerTy = dc->getDeclaredTypeInContext();
      VarDecl *overridden = nullptr;
      MemberLookup lookup(containerTy, name, *Impl.firstClangModule);
      for (const auto &result : lookup.Results) {
        if (isa<FuncDecl>(result.D))
          return nullptr;

        if (auto var = dyn_cast<VarDecl>(result.D))
          overridden = var;
      }

      auto type = Impl.importType(decl->getType());
      if (!type)
        return nullptr;

      // Look for an iboutletcollection attribute, which provides additional
      // typing information for known containers.
      if (auto collectionAttr = decl->getAttr<clang::IBOutletCollectionAttr>()){
        if (auto elementType = Impl.importType(collectionAttr->getInterface())){
          type = getTypedCollection(type, elementType);
        }
      }

      // Import the getter.
      auto getter
        = cast_or_null<FuncDecl>(Impl.importDecl(decl->getGetterMethodDecl()));
      if (!getter && decl->getGetterMethodDecl())
        return nullptr;

      // Import the setter, if there is one.
      auto setter
        = cast_or_null<FuncDecl>(Impl.importDecl(decl->getSetterMethodDecl()));
      if (!setter && decl->getSetterMethodDecl())
        return nullptr;
      
      auto result = new (Impl.SwiftContext)
                      VarDecl(Impl.importSourceLoc(decl->getLocation()),
                              name, type, dc);

      // Build thunks.
      FuncDecl *getterThunk = buildGetterThunk(getter, dc, nullptr);
      getterThunk->makeGetter(result);

      FuncDecl *setterThunk = nullptr;
      if (setter) {
        setterThunk = buildSetterThunk(setter, dc, nullptr);
        setterThunk->makeSetter(result);
      }

      // Turn this into a property.
      // FIXME: Fake locations for '{' and '}'?
      result->setProperty(Impl.SwiftContext, SourceLoc(),
                          getterThunk, setterThunk,
                          SourceLoc());

      // Handle attributes.
      if (decl->hasAttr<clang::IBOutletAttr>())
        result->getMutableAttrs().IBOutlet = true;
      // FIXME: Handle IBOutletCollection.

      if (overridden) {
        result->setOverriddenDecl(overridden);
      }

      return result;
    }

    Decl *
    VisitObjCCompatibleAliasDecl(clang::ObjCCompatibleAliasDecl *decl) {
      // Like C++ using declarations, name lookup simply looks through
      // Objective-C compatibility aliases. They are not imported directly.
      return nullptr;
    }

    Decl *VisitLinkageSpecDecl(clang::LinkageSpecDecl *decl) {
      // Linkage specifications are not imported.
      return nullptr;
    }

    Decl *VisitObjCPropertyImplDecl(clang::ObjCPropertyImplDecl *decl) {
      // @synthesize and @dynamic are not imported, since they are not part
      // of the interface to a class.
      return nullptr;
    }

    Decl *VisitFileScopeAsmDecl(clang::FileScopeAsmDecl *decl) {
      return nullptr;
    }

    Decl *VisitAccessSpecDecl(clang::AccessSpecDecl *decl) {
      return nullptr;
    }

    Decl *VisitFriendDecl(clang::FriendDecl *decl) {
      // Friends are not imported; Swift has a different access control
      // mechanism.
      return nullptr;
    }

    Decl *VisitFriendTemplateDecl(clang::FriendTemplateDecl *decl) {
      // Friends are not imported; Swift has a different access control
      // mechanism.
      return nullptr;
    }

    Decl *VisitStaticAssertDecl(clang::StaticAssertDecl *decl) {
      // Static assertions are an implementation detail.
      return nullptr;
    }

    Decl *VisitBlockDecl(clang::BlockDecl *decl) {
      // Blocks are not imported (although block types can be imported).
      return nullptr;
    }

    Decl *VisitClassScopeFunctionSpecializationDecl(
                 clang::ClassScopeFunctionSpecializationDecl *decl) {
      // Note: templates are not imported.
      return nullptr;
    }

    Decl *VisitImportDecl(clang::ImportDecl *decl) {
      // Transitive module imports are not handled at the declaration level.
      // Rather, they are understood from the module itself.
      return nullptr;
    }
  };
}

Decl *ClangImporter::Implementation::importDecl(clang::NamedDecl *decl) {
  if (!decl)
    return nullptr;
  
  auto known = ImportedDecls.find(decl->getCanonicalDecl());
  if (known != ImportedDecls.end())
    return known->second;

  SwiftDeclConverter converter(*this);
  auto result = converter.Visit(decl);
  auto canon = decl->getCanonicalDecl();
  if (result) {
    assert(!result->getClangDecl() || result->getClangDecl() == canon);
    result->setClangDecl(canon);
  }
  return ImportedDecls[canon] = result;
}

DeclContext *
ClangImporter::Implementation::importDeclContext(clang::DeclContext *dc) {
  // FIXME: Should map to the module we want to import into (?).
  if (dc->isTranslationUnit())
    return firstClangModule;
  
  auto decl = dyn_cast<clang::NamedDecl>(dc);
  if (!decl)
    return nullptr;

  auto swiftDecl = importDecl(decl);
  if (!swiftDecl)
    return nullptr;

  if (auto nominal = dyn_cast<NominalTypeDecl>(swiftDecl))
    return nominal;
  if (auto extension = dyn_cast<ExtensionDecl>(swiftDecl))
    return extension;
  if (auto constructor = dyn_cast<ConstructorDecl>(swiftDecl))
    return constructor;
  if (auto destructor = dyn_cast<DestructorDecl>(swiftDecl))
    return destructor;
  return nullptr;
}