Skip to content

Commit fc7588b

Browse files
ahoppenahoppen
committed
[SourceKit] Make the SourceKit plugin infrastructure buildable on Linux and Windows
1 parent 40b91aa commit fc7588b

File tree

4 files changed

+267
-43
lines changed

4 files changed

+267
-43
lines changed

‎lib/Basic/LoadDynamicLibrary.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717
#define NOMINMAX
1818
#include "llvm/Support/ConvertUTF.h"
1919
#include "llvm/Support/Windows/WindowsSupport.h"
20+
#include "swift/Basic/LLVM.h"
2021
#include <windows.h>
2122
#else
2223
#include <dlfcn.h>

‎tools/SourceKit/tools/sourcekitd/lib/API/sourcekitdAPI-Common.cpp

Lines changed: 28 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -896,7 +896,7 @@ void YAMLRequestParser::initError(StringRef Desc, llvm::yaml::Node *Node,
896896
sourcekitd_variant_functions_t sourcekitd_variant_functions_create() {
897897
auto *vfuncs = new VariantFunctions();
898898
// Zero-initialize.
899-
bzero(vfuncs, sizeof(VariantFunctions));
899+
memset(vfuncs, 0, sizeof(VariantFunctions));
900900
return vfuncs;
901901
}
902902

@@ -1133,3 +1133,30 @@ PluginInitParams::PluginInitParams(
11331133
};
11341134
this->opaqueIDEInspectionInstance = opaqueIDEInspectionInstance;
11351135
}
1136+
1137+
// MARK: Plugin variant functions
1138+
1139+
// Note: only modified during plugin loading.
1140+
static std::vector<VariantFunctions *> PluginVariantFunctions;
1141+
1142+
VariantFunctions *getPluginVariantFunctions(size_t BufKind) {
1143+
size_t index = BufKind - (size_t)CustomBufferKind::CustomBufferKind_End;
1144+
if (index >= PluginVariantFunctions.size() ||
1145+
PluginVariantFunctions[index] == nullptr) {
1146+
llvm::report_fatal_error(
1147+
"unknown custom buffer kind; possible plugin loading failure");
1148+
}
1149+
return PluginVariantFunctions[index];
1150+
}
1151+
1152+
void sourcekitd::pluginRegisterCustomBufferKind(
1153+
uint64_t kind, sourcekitd_variant_functions_t funcs) {
1154+
auto index = kind - (uint64_t)CustomBufferKind::CustomBufferKind_End;
1155+
if (index < PluginVariantFunctions.size()) {
1156+
assert(PluginVariantFunctions[index] == nullptr &&
1157+
"overwriting existing buffer");
1158+
} else {
1159+
PluginVariantFunctions.resize(index + 1);
1160+
}
1161+
PluginVariantFunctions[index] = static_cast<VariantFunctions *>(funcs);
1162+
}

‎tools/SourceKit/tools/sourcekitd/lib/API/sourcekitdAPI-InProc.cpp

Lines changed: 238 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -281,6 +281,8 @@ class SKDCustomData: public SKDObject {
281281
return SOURCEKITD_VARIANT_TYPE_ARRAY;
282282
case CustomBufferKind::RawData:
283283
return SOURCEKITD_VARIANT_TYPE_DATA;
284+
case CustomBufferKind::CustomBufferKind_End:
285+
llvm_unreachable("Not a valid variant type");
284286
}
285287
llvm::report_fatal_error("sourcekitd object did not resolve to a known type");
286288
}
@@ -501,6 +503,82 @@ sourcekitd_request_dictionary_set_uid(sourcekitd_object_t dict,
501503
static_cast<SKDObject *>(dict)->set(key, new SKDUID(uid));
502504
}
503505

506+
sourcekitd_object_t
507+
sourcekitd_request_dictionary_get_value(sourcekitd_object_t dict,
508+
sourcekitd_uid_t key) {
509+
return static_cast<sourcekitd_object_t>(static_cast<SKDObject *>(dict)->get(key).get());
510+
}
511+
512+
const char *sourcekitd_request_dictionary_get_string(sourcekitd_object_t dict,
513+
sourcekitd_uid_t key) {
514+
return static_cast<SKDObject *>(dict)->get(key)->getCString();
515+
}
516+
517+
int64_t sourcekitd_request_dictionary_get_int64(sourcekitd_object_t dict,
518+
sourcekitd_uid_t key) {
519+
return *static_cast<SKDObject *>(dict)->get(key)->getInt64();
520+
}
521+
522+
bool sourcekitd_request_dictionary_get_bool(sourcekitd_object_t dict,
523+
sourcekitd_uid_t key) {
524+
return static_cast<SKDObject *>(dict)->get(key)->getBool();
525+
}
526+
527+
sourcekitd_uid_t sourcekitd_request_dictionary_get_uid(sourcekitd_object_t dict,
528+
sourcekitd_uid_t key) {
529+
return static_cast<SKDObject *>(dict)->get(key)->getUID();
530+
}
531+
532+
size_t sourcekitd_request_array_get_count(sourcekitd_object_t array) {
533+
return static_cast<SKDObject *>(array)->getCount();
534+
}
535+
536+
sourcekitd_object_t
537+
sourcekitd_request_array_get_value(sourcekitd_object_t array, size_t index) {
538+
return static_cast<sourcekitd_object_t>(static_cast<SKDObject *>(array)->get(index).get());
539+
}
540+
541+
const char *sourcekitd_request_array_get_string(sourcekitd_object_t array,
542+
size_t index) {
543+
return static_cast<SKDObject *>(array)->get(index)->getCString();
544+
}
545+
546+
int64_t sourcekitd_request_array_get_int64(sourcekitd_object_t array,
547+
size_t index) {
548+
return *static_cast<SKDObject *>(array)->get(index)->getInt64();
549+
}
550+
551+
bool sourcekitd_request_array_get_bool(sourcekitd_object_t array,
552+
size_t index) {
553+
return static_cast<SKDObject *>(array)->get(index)->getBool();
554+
}
555+
556+
sourcekitd_uid_t sourcekitd_request_array_get_uid(sourcekitd_object_t array,
557+
size_t index) {
558+
return static_cast<SKDObject *>(array)->get(index)->getUID();
559+
}
560+
561+
int64_t sourcekitd_request_int64_get_value(sourcekitd_object_t obj) {
562+
return *static_cast<SKDObject *>(obj)->getInt64();
563+
}
564+
565+
bool sourcekitd_request_bool_get_value(sourcekitd_object_t obj) {
566+
return static_cast<SKDObject *>(obj)->getBool();
567+
}
568+
569+
size_t sourcekitd_request_string_get_length(sourcekitd_object_t obj) {
570+
return static_cast<SKDString *>(obj)->getString()->size();
571+
}
572+
573+
const char *sourcekitd_request_string_get_ptr(sourcekitd_object_t obj) {
574+
return static_cast<SKDString *>(obj)->getCString();
575+
}
576+
577+
sourcekitd_uid_t sourcekitd_request_uid_get_value(sourcekitd_object_t obj) {
578+
return static_cast<SKDUID *>(obj)->getUID();
579+
}
580+
581+
504582
sourcekitd_object_t
505583
sourcekitd_request_array_create(const sourcekitd_object_t *objects,
506584
size_t count) {
@@ -836,6 +914,12 @@ sourcekitd::createErrorRequestFailed(StringRef Description) {
836914
Description));
837915
}
838916

917+
sourcekitd_response_t
918+
sourcekitd::createErrorRequestInterrupted(StringRef Description) {
919+
return retained(new SKDError(SOURCEKITD_ERROR_CONNECTION_INTERRUPTED,
920+
Description));
921+
}
922+
839923
sourcekitd_response_t
840924
sourcekitd::createErrorRequestCancelled() {
841925
return retained(new SKDError(SOURCEKITD_ERROR_REQUEST_CANCELLED,
@@ -857,10 +941,11 @@ static sourcekitd_variant_type_t SKDVar_get_type(sourcekitd_variant_t var) {
857941

858942
static bool SKDVar_array_apply(
859943
sourcekitd_variant_t array,
860-
llvm::function_ref<bool(size_t, sourcekitd_variant_t)> applier) {
944+
sourcekitd_variant_array_applier_f_t applier,
945+
void *context) {
861946
return dyn_cast<SKDArray>(SKD_OBJ(array))->apply([&](size_t Index,
862947
SKDObjectRef Object){
863-
return applier(Index, variantFromSKDObject(Object));
948+
return applier(Index, variantFromSKDObject(Object), context);
864949
});
865950
}
866951

@@ -906,10 +991,11 @@ static double SKDVar_double_get_value(sourcekitd_variant_t obj) {
906991

907992
static bool SKDVar_dictionary_apply(
908993
sourcekitd_variant_t dict,
909-
llvm::function_ref<bool(sourcekitd_uid_t, sourcekitd_variant_t)> applier) {
994+
sourcekitd_variant_dictionary_applier_f_t applier,
995+
void *context) {
910996
return dyn_cast<SKDDictionary>(SKD_OBJ(dict))->apply([&](sourcekitd_uid_t Key,
911997
SKDObjectRef Object){
912-
return applier(Key, variantFromSKDObject(Object));
998+
return applier(Key, variantFromSKDObject(Object), context);
913999
});
9141000
}
9151001

@@ -1051,8 +1137,156 @@ static sourcekitd_variant_t variantFromSKDObject(SKDObjectRef Object) {
10511137
return {{ (uintptr_t)getVariantFunctionsForRawData(),
10521138
(uintptr_t)DataObject->getDataPtr(),
10531139
(uintptr_t)DataObject->getDataSize() }};
1140+
case CustomBufferKind::CustomBufferKind_End:
1141+
llvm_unreachable("Not a valid variant type");
10541142
}
10551143
}
10561144

10571145
return {{ (uintptr_t)&SKDVariantFuncs, (uintptr_t)Object.get(), 0 }};
10581146
}
1147+
1148+
sourcekitd_response_t
1149+
sourcekitd_response_error_create(sourcekitd_error_t kind,
1150+
const char *description) {
1151+
SKDError *error = new SKDError(kind, description);
1152+
return retained(error);
1153+
}
1154+
1155+
sourcekitd_response_t
1156+
sourcekitd_response_dictionary_create(const sourcekitd_uid_t *keys,
1157+
const sourcekitd_response_t *values,
1158+
size_t count) {
1159+
// Request and response dictionaries are represented by the same type.
1160+
return sourcekitd_request_dictionary_create(keys, values, count);
1161+
}
1162+
1163+
void sourcekitd_response_dictionary_set_value(sourcekitd_response_t dict,
1164+
sourcekitd_uid_t key,
1165+
sourcekitd_response_t value) {
1166+
static_cast<SKDObject *>(dict)->set(key, static_cast<SKDObject *>(value));
1167+
}
1168+
1169+
void sourcekitd_response_dictionary_set_string(sourcekitd_response_t dict,
1170+
sourcekitd_uid_t key,
1171+
const char *string) {
1172+
static_cast<SKDObject *>(dict)->set(key, new SKDString(std::string(string)));
1173+
}
1174+
1175+
void sourcekitd_response_dictionary_set_stringbuf(sourcekitd_response_t dict,
1176+
sourcekitd_uid_t key,
1177+
const char *buf,
1178+
size_t length) {
1179+
llvm::SmallString<512> SS;
1180+
SS += StringRef(buf, length);
1181+
sourcekitd_response_dictionary_set_string(dict, key, SS.c_str());
1182+
}
1183+
1184+
void sourcekitd_response_dictionary_set_int64(sourcekitd_response_t dict,
1185+
sourcekitd_uid_t key,
1186+
int64_t val) {
1187+
static_cast<SKDObject *>(dict)->set(key, new SKDInt64(val));
1188+
}
1189+
1190+
void sourcekitd_response_dictionary_set_bool(sourcekitd_response_t dict,
1191+
sourcekitd_uid_t key, bool val) {
1192+
static_cast<SKDObject *>(dict)->set(key, new SKDBool(val));
1193+
}
1194+
1195+
void sourcekitd_response_dictionary_set_double(sourcekitd_response_t dict,
1196+
sourcekitd_uid_t key,
1197+
double val) {
1198+
static_cast<SKDObject *>(dict)->set(key, new SKDDouble(val));
1199+
}
1200+
1201+
void sourcekitd_response_dictionary_set_uid(sourcekitd_response_t dict,
1202+
sourcekitd_uid_t key,
1203+
sourcekitd_uid_t uid) {
1204+
static_cast<SKDObject *>(dict)->set(key, new SKDUID(uid));
1205+
}
1206+
1207+
sourcekitd_response_t
1208+
sourcekitd_response_array_create(const sourcekitd_response_t *objects,
1209+
size_t count) {
1210+
// Request and response arrays are represented by the same type.
1211+
return sourcekitd_request_array_create(objects, count);
1212+
}
1213+
1214+
void sourcekitd_response_array_set_value(sourcekitd_response_t array,
1215+
size_t index,
1216+
sourcekitd_response_t value) {
1217+
static_cast<SKDObject *>(array)->set(index, static_cast<SKDObject *>(value));
1218+
}
1219+
1220+
void sourcekitd_response_array_set_string(sourcekitd_response_t array,
1221+
size_t index, const char *string) {
1222+
static_cast<SKDObject *>(array)->set(index,
1223+
new SKDString(std::string(string)));
1224+
}
1225+
1226+
void sourcekitd_response_array_set_stringbuf(sourcekitd_response_t array,
1227+
size_t index, const char *buf,
1228+
size_t length) {
1229+
llvm::SmallString<512> SS;
1230+
SS += StringRef(buf, length);
1231+
sourcekitd_response_array_set_string(array, index, SS.c_str());
1232+
}
1233+
1234+
void sourcekitd_response_array_set_int64(sourcekitd_response_t array,
1235+
size_t index, int64_t val) {
1236+
static_cast<SKDObject *>(array)->set(index, new SKDInt64(val));
1237+
}
1238+
1239+
void sourcekitd_response_array_set_double(sourcekitd_response_t array,
1240+
size_t index, double val) {
1241+
static_cast<SKDObject *>(array)->set(index, new SKDDouble(val));
1242+
}
1243+
1244+
void sourcekitd_response_array_set_uid(sourcekitd_response_t array,
1245+
size_t index, sourcekitd_uid_t uid) {
1246+
static_cast<SKDObject *>(array)->set(index, new SKDUID(uid));
1247+
}
1248+
1249+
sourcekitd_response_t sourcekitd_response_retain(sourcekitd_response_t object) {
1250+
return retained(static_cast<SKDObject *>(object));
1251+
}
1252+
1253+
sourcekitd_variant_type_t sourcekitd_request_get_type(sourcekitd_object_t obj) {
1254+
if (!obj) {
1255+
return SOURCEKITD_VARIANT_TYPE_NULL;
1256+
}
1257+
switch (static_cast<SKDObject *>(obj)->getKind()) {
1258+
case SKDObject::ObjectKind::Dictionary:
1259+
return SOURCEKITD_VARIANT_TYPE_DICTIONARY;
1260+
case SKDObject::ObjectKind::Array:
1261+
return SOURCEKITD_VARIANT_TYPE_ARRAY;
1262+
case SKDObject::ObjectKind::String:
1263+
return SOURCEKITD_VARIANT_TYPE_STRING;
1264+
case SKDObject::ObjectKind::Int64:
1265+
return SOURCEKITD_VARIANT_TYPE_INT64;
1266+
case SKDObject::ObjectKind::UID:
1267+
return SOURCEKITD_VARIANT_TYPE_UID;
1268+
case SKDObject::ObjectKind::Bool:
1269+
return SOURCEKITD_VARIANT_TYPE_BOOL;
1270+
case SKDObject::ObjectKind::Double:
1271+
return SOURCEKITD_VARIANT_TYPE_DOUBLE;
1272+
case SKDObject::ObjectKind::CustomData:
1273+
return static_cast<SKDObject *>(obj)->getVariantType();
1274+
case SKDObject::ObjectKind::Error:
1275+
llvm_unreachable("Should not be part of a request");
1276+
}
1277+
}
1278+
1279+
void sourcekitd_response_dictionary_set_custom_buffer(
1280+
sourcekitd_response_t dict, sourcekitd_uid_t key, const void *ptr,
1281+
size_t size) {
1282+
#ifndef NDEBUG
1283+
assert(size >= sizeof(uint64_t));
1284+
auto bufKind = *(const uint64_t *)ptr;
1285+
assert(bufKind >= (uint64_t)CustomBufferKind::CustomBufferKind_End);
1286+
#endif
1287+
std::unique_ptr<llvm::WritableMemoryBuffer> Buf;
1288+
Buf = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(size);
1289+
memcpy(Buf->getBufferStart(), ptr, size);
1290+
static_cast<SKDObject *>(dict)->set(key,
1291+
new SKDCustomData(std::move(Buf)));
1292+
}

‎tools/SourceKit/tools/sourcekitd/lib/API/sourcekitdAPI-XPC.cpp

Lines changed: 0 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -670,19 +670,6 @@ sourcekitd_response_get_value(sourcekitd_response_t resp) {
670670
((const void*)(((const uint64_t*)xpc_data_get_bytes_ptr(xobj))+1))
671671
#define CUSTOM_BUF_SIZE(xobj) (xpc_data_get_length(xobj) - sizeof(uint64_t))
672672

673-
// Note: only modified during plugin loading.
674-
static std::vector<VariantFunctions *> PluginVariantFunctions;
675-
676-
VariantFunctions *getPluginVariantFunctions(size_t BufKind) {
677-
size_t index = BufKind - (size_t)CustomBufferKind::CustomBufferKind_End;
678-
if (index >= PluginVariantFunctions.size() ||
679-
PluginVariantFunctions[index] == nullptr) {
680-
llvm::report_fatal_error(
681-
"unknown custom buffer kind; possible plugin loading failure");
682-
}
683-
return PluginVariantFunctions[index];
684-
}
685-
686673
static sourcekitd_variant_type_t XPCVar_get_type(sourcekitd_variant_t var) {
687674
xpc_object_t obj = XPC_OBJ(var);
688675

@@ -1060,28 +1047,3 @@ sourcekitd_variant_type_t sourcekitd_request_get_type(sourcekitd_object_t obj) {
10601047
return SOURCEKITD_VARIANT_TYPE_NULL;
10611048
llvm::report_fatal_error("unkown sourcekitd_object_t type");
10621049
}
1063-
1064-
void sourcekitd::pluginRegisterCustomBufferKind(
1065-
uint64_t kind, sourcekitd_variant_functions_t funcs) {
1066-
auto index = kind - (uint64_t)CustomBufferKind::CustomBufferKind_End;
1067-
if (index < PluginVariantFunctions.size()) {
1068-
assert(PluginVariantFunctions[index] == nullptr &&
1069-
"overwriting existing buffer");
1070-
} else {
1071-
PluginVariantFunctions.resize(index + 1);
1072-
}
1073-
PluginVariantFunctions[index] = static_cast<VariantFunctions *>(funcs);
1074-
}
1075-
1076-
void sourcekitd_response_dictionary_set_custom_buffer(
1077-
sourcekitd_response_t dict, sourcekitd_uid_t key, const void *ptr,
1078-
size_t size) {
1079-
#ifndef NDEBUG
1080-
assert(size >= sizeof(uint64_t));
1081-
auto bufKind = *(const uint64_t *)ptr;
1082-
assert(bufKind >= (uint64_t)CustomBufferKind::CustomBufferKind_End);
1083-
#endif
1084-
xpc_object_t xdata = xpc_data_create(ptr, size);
1085-
xpc_dictionary_set_value(dict, strFromUID(key), xdata);
1086-
xpc_release(xdata);
1087-
}

0 commit comments

Comments
 (0)