[swiftc/msvc] Compiling with MSVC (#1516)

Some modifications for the ms-extension option of the clang.exe in the Visual Studio 2015 development environment

This patch is only for swiftc.exe. I used the library set of Visual Studio 2015 Update 1 and recent version of swift-clang as the compiler. If you are using the real MSVC compiler, more patch might be required.

Author: tinysun212

include/swift/Basic/JSONSerialization.h

@@ -481,6 +481,16 @@ struct ScalarTraits<uint32_t> {
   static bool mustQuote(StringRef) { return false; }
 };
 
+#if defined(_MSC_VER)
+// In MSVC, 'unsigned long' is 32bit size and different from uint32_t,
+// and it is used to define swift::sys::ProcessId.
+template<>
+struct ScalarTraits<unsigned long> {
+  static void output(const unsigned long &, llvm::raw_ostream &);
+  static bool mustQuote(StringRef) { return false; }
+};
+#endif
+
 template<>
 struct ScalarTraits<uint64_t> {
   static void output(const uint64_t &, llvm::raw_ostream &);

include/swift/Basic/Malloc.h

@@ -19,7 +19,11 @@
 #define SWIFT_BASIC_MALLOC_H
 
 #include <cassert>
+#if defined(_MSC_VER)
+#include <malloc.h>
+#else
 #include <cstdlib>
+#endif
 
 namespace swift {
 

include/swift/IDE/CommentConversion.h

@@ -15,6 +15,7 @@
 
 #include "swift/Basic/LLVM.h"
 #include <memory>
+#include <string>
 
 namespace swift {
 class Decl;

include/swift/SILOptimizer/Utils/Local.h

@@ -485,14 +485,23 @@ class CastOptimizer {
 
 public:
   CastOptimizer(std::function<void (SILInstruction *I, ValueBase *V)> ReplaceInstUsesAction,
-                std::function<void (SILInstruction *)> EraseAction = [](SILInstruction*){},
-                std::function<void ()> WillSucceedAction = [](){},
+                std::function<void (SILInstruction *)> EraseAction,
+                std::function<void ()> WillSucceedAction,
                 std::function<void ()> WillFailAction = [](){})
     : ReplaceInstUsesAction(ReplaceInstUsesAction),
       EraseInstAction(EraseAction),
       WillSucceedAction(WillSucceedAction),
       WillFailAction(WillFailAction) {}
 
+  // This constructor is used in
+  // 'SILOptimizer/Mandatory/ConstantPropagation.cpp'. MSVC2015 compiler
+  // couldn't use the single constructor version which has three default
+  // arguments. It seems the number of the default argument with lambda is
+  // limited.
+  CastOptimizer(std::function<void (SILInstruction *I, ValueBase *V)> ReplaceInstUsesAction,
+                std::function<void (SILInstruction *)> EraseAction = [](SILInstruction*){})
+    : CastOptimizer(ReplaceInstUsesAction, EraseAction, [](){}, [](){}) {}
+
   /// Simplify checked_cast_br. It may change the control flow.
   SILInstruction *
   simplifyCheckedCastBranchInst(CheckedCastBranchInst *Inst);

lib/Basic/JSONSerialization.cpp

@@ -261,6 +261,13 @@ void ScalarTraits<uint32_t>::output(const uint32_t &Val,
   Out << Val;
 }
 
+#if defined(_MSC_VER)
+void ScalarTraits<unsigned long>::output(const unsigned long &Val,
+                                         raw_ostream &Out) {
+  Out << Val;
+}
+#endif
+
 void ScalarTraits<uint64_t>::output(const uint64_t &Val,
                                     raw_ostream &Out) {
   Out << Val;

lib/Driver/Compilation.cpp

@@ -631,8 +631,16 @@ int Compilation::performSingleCommand(const Job *Cmd) {
   const char *ExecPath = Cmd->getExecutable();
   const char **argv = Argv.data();
 
-  for (auto &envPair : Cmd->getExtraEnvironment())
+  for (auto &envPair : Cmd->getExtraEnvironment()) {
+#if defined(_MSC_VER)
+    llvm::SmallString<256> envStr = StringRef(envPair.first);
+    envStr.append(StringRef("="));
+    envStr.append(StringRef(envPair.second));
+    _putenv(envStr.c_str());
+#else
     setenv(envPair.first, envPair.second, /*replacing=*/true);
+#endif
+  }
 
   return ExecuteInPlace(ExecPath, argv);
 }

lib/Immediate/Immediate.cpp

@@ -37,17 +37,27 @@
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 #include "llvm/Support/Path.h"
-
+#if defined(_MSC_VER)
+#include "Windows.h"
+#else
 #include <dlfcn.h>
-
+#endif
 using namespace swift;
 using namespace swift::immediate;
 
+static bool loadRuntimeLib(StringRef runtimeLibPathWithName) {
+#if defined(_MSC_VER)
+  return LoadLibrary(runtimeLibPathWithName.str().c_str());
+#else
+  return dlopen(runtimeLibPathWithName.str().c_str(), RTLD_LAZY | RTLD_GLOBAL);
+#endif
+}
+
 static bool loadRuntimeLib(StringRef sharedLibName, StringRef runtimeLibPath) {
   // FIXME: Need error-checking.
   llvm::SmallString<128> Path = runtimeLibPath;
   llvm::sys::path::append(Path, sharedLibName);
-  return dlopen(Path.c_str(), RTLD_LAZY | RTLD_GLOBAL);
+  return loadRuntimeLib(Path);
 }
 
 bool swift::immediate::loadSwiftRuntime(StringRef runtimeLibPath) {
@@ -60,7 +70,7 @@ static bool tryLoadLibrary(LinkLibrary linkLib,
 
   // If we have an absolute or relative path, just try to load it now.
   if (llvm::sys::path::has_parent_path(path.str())) {
-    return dlopen(path.c_str(), RTLD_LAZY | RTLD_GLOBAL);
+    return loadRuntimeLib(path);
   }
 
   bool success = false;
@@ -80,14 +90,14 @@ static bool tryLoadLibrary(LinkLibrary linkLib,
     for (auto &libDir : searchPathOpts.LibrarySearchPaths) {
       path = libDir;
       llvm::sys::path::append(path, stem.str());
-      success = dlopen(path.c_str(), RTLD_LAZY | RTLD_GLOBAL);
+      success = loadRuntimeLib(path);
       if (success)
         break;
     }
 
-    // Let dlopen determine the best search paths.
+    // Let loadRuntimeLib determine the best search paths.
     if (!success)
-      success = dlopen(stem.c_str(), RTLD_LAZY | RTLD_GLOBAL);
+      success = loadRuntimeLib(stem);
 
     // If that fails, try our runtime library path.
     if (!success)
@@ -106,14 +116,14 @@ static bool tryLoadLibrary(LinkLibrary linkLib,
     for (auto &frameworkDir : searchPathOpts.FrameworkSearchPaths) {
       path = frameworkDir;
       llvm::sys::path::append(path, frameworkPart.str());
-      success = dlopen(path.c_str(), RTLD_LAZY | RTLD_GLOBAL);
+      success = loadRuntimeLib(path);
       if (success)
         break;
     }
 
-    // If that fails, let dlopen search for system frameworks.
+    // If that fails, let loadRuntimeLib search for system frameworks.
     if (!success)
-      success = dlopen(frameworkPart.c_str(), RTLD_LAZY | RTLD_GLOBAL);
+      success = loadRuntimeLib(frameworkPart);
     break;
   }
   }

lib/Sema/CSDiag.cpp

@@ -879,9 +879,9 @@ namespace {
                       unsigned level,
                       ArrayRef<CallArgParam> actualArgs);
 
-    void filterList(ArrayRef<CallArgParam> actualArgs);
+    void filterListArgs(ArrayRef<CallArgParam> actualArgs);
     void filterList(Type actualArgsType) {
-      return filterList(decomposeArgType(actualArgsType));
+      return filterListArgs(decomposeArgType(actualArgsType));
     }
     void filterList(ClosenessPredicate predicate);
     void filterContextualMemberList(Expr *argExpr);
@@ -1483,7 +1483,7 @@ void CalleeCandidateInfo::collectCalleeCandidates(Expr *fn) {
 /// After the candidate list is formed, it can be filtered down to discard
 /// obviously mismatching candidates and compute a "closeness" for the
 /// resultant set.
-void CalleeCandidateInfo::filterList(ArrayRef<CallArgParam> actualArgs) {
+void CalleeCandidateInfo::filterListArgs(ArrayRef<CallArgParam> actualArgs) {
   // Now that we have the candidate list, figure out what the best matches from
   // the candidate list are, and remove all the ones that aren't at that level.
   filterList([&](UncurriedCandidate candidate) -> ClosenessResultTy {
@@ -1530,7 +1530,7 @@ void CalleeCandidateInfo::filterContextualMemberList(Expr *argExpr) {
 
     CallArgParam param;
     param.Ty = argType;
-    return filterList(param);
+    return filterListArgs(param);
   }
 
   // If we have a tuple expression, form a tuple type.
@@ -1547,7 +1547,7 @@ void CalleeCandidateInfo::filterContextualMemberList(Expr *argExpr) {
     ArgElts.push_back(param);
   }
 
-  return filterList(ArgElts);
+  return filterListArgs(ArgElts);
 }
 
 CalleeCandidateInfo::CalleeCandidateInfo(Type baseType,