Skip to content
This repository was archived by the owner on Dec 12, 2024. It is now read-only.

Commit 474b420

Browse files
stephen-hawleystephen-hawley
authored
Merge pull request #832 from xamarin/add-vtable-handle-toreceiver
Add gchandle to all receivers
2 parents 5caa5df + ec25582 commit 474b420

File tree

4 files changed

+52
-46
lines changed

4 files changed

+52
-46
lines changed

‎SwiftReflector/MarshalEngineCSafeSwiftToCSharp.cs

Lines changed: 28 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -59,13 +59,13 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSFunc (CSType thisType, st
5959

6060

6161
if (isSetter) {
62-
var valueID = delegateParams [1].Name;
62+
var valueID = delegateParams [2].Name;
6363
valueExpr = valueID;
6464
var swiftNewValue = funcDecl.ParameterLists [1] [0];
6565
bool newValueIsGeneric = funcDecl.IsTypeSpecGeneric (funcDecl.PropertyType);
6666
entity = !newValueIsGeneric ? typeMapper.GetEntityForTypeSpec (swiftNewValue.TypeSpec) : null;
6767
entityType = !newValueIsGeneric ? typeMapper.GetEntityTypeForTypeSpec (swiftNewValue.TypeSpec) : EntityType.None;
68-
var isUnusualNewValue = IsUnusualParameter (entity, delegateParams [1]);
68+
var isUnusualNewValue = IsUnusualParameter (entity, delegateParams [2]);
6969
var newValueIsBool = entityType == EntityType.Scalar && swiftNewValue.TypeName == "Swift.Bool";
7070

7171
if (entityType == EntityType.Class || entity != null && entity.IsObjCProtocol) {
@@ -129,7 +129,7 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSFunc (CSType thisType, st
129129

130130
int j = 0;
131131
int k = isSetter ? 1 : 0;
132-
for (int i = (funcDecl.HasThrows || returnIsStruct || returnIsProtocol || isSetter || returnIsGeneric || returnIsSelf) ? 2 : 1; i < delegateParams.Count; i++, j++, k++) {
132+
for (int i = (funcDecl.HasThrows || returnIsStruct || returnIsProtocol || isSetter || returnIsGeneric || returnIsSelf) ? 3 : 2; i < delegateParams.Count; i++, j++, k++) {
133133
var swiftParm = funcDecl.ParameterLists [1] [k];
134134
bool parmIsGeneric = funcDecl.IsTypeSpecGeneric (swiftParm);
135135
entity = !parmIsGeneric ? typeMapper.GetEntityForTypeSpec (swiftParm.TypeSpec) : null;
@@ -149,7 +149,7 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSFunc (CSType thisType, st
149149
use.AddIfNotPresent (typeof (SwiftObjectRegistry));
150150

151151
var fullClassName = entity.Type.ToFullyQualifiedName (true);
152-
var retrievecall = NewClassCompiler.SafeMarshalClassFromIntPtr (delegateParams [0].Name, csParmType, use, fullClassName, typeMapper, entity.IsObjCProtocol);
152+
var retrievecall = NewClassCompiler.SafeMarshalClassFromIntPtr (delegateParams [1].Name, csParmType, use, fullClassName, typeMapper, entity.IsObjCProtocol);
153153
if (csParm.ParameterKind == CSParameterKind.Out || csParm.ParameterKind == CSParameterKind.Ref) {
154154
string id = MarshalEngine.Uniqueify (delegateParams [i].Name.Name, identifiersUsed);
155155
identifiersUsed.Add (id);
@@ -331,25 +331,25 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSFunc (CSType thisType, st
331331
postMarshalCode.Add (CSFunctionCall.FunctionCallLine ("StructMarshal.Marshaler.ToSwift", false,
332332
methodType.Typeof (),
333333
retvalId,
334-
delegateParams [0].Name));
334+
delegateParams [1].Name));
335335
altBody.Add (CSFunctionCall.FunctionCallLine ("StructMarshal.Marshaler.SetErrorNotThrown", false,
336-
delegateParams [0].Name, returnTuple.Typeof ()));
336+
delegateParams [1].Name, returnTuple.Typeof ()));
337337
} else {
338338
if (isSetter) {
339339
altBody.Add (CSAssignment.Assign (invoker, CSAssignmentOperator.Assign, valueExpr));
340340
} else {
341341
altBody.Add (new CSLine (invoker));
342342
}
343343
altBody.Add (CSFunctionCall.FunctionCallLine ("StructMarshal.Marshaler.SetErrorNotThrown", false,
344-
delegateParams [0].Name, returnTuple.Typeof ()));
344+
delegateParams [1].Name, returnTuple.Typeof ()));
345345

346346
}
347347
string swiftError = MarshalEngine.Uniqueify ("err", identifiersUsed);
348348
var swiftErrorIdentifier = new CSIdentifier (swiftError);
349349
catchBlock.Add (CSFieldDeclaration.VarLine (new CSSimpleType (typeof (SwiftError)), swiftErrorIdentifier,
350350
new CSFunctionCall ("SwiftError.FromException", false, catchID)));
351351
catchBlock.Add (CSFunctionCall.FunctionCallLine ("StructMarshal.Marshaler.SetErrorThrown", false,
352-
delegateParams [0].Name,
352+
delegateParams [1].Name,
353353
swiftErrorIdentifier,
354354
returnTuple.Typeof ()));
355355
} else {
@@ -369,43 +369,43 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSFunc (CSType thisType, st
369369
var returnContainerId = new CSIdentifier (returnContainer);
370370
var protoGetter = new CSFunctionCall ($"SwiftObjectRegistry.Registry.ExistentialContainerForProtocols", false, retvalId, methodType.Typeof ());
371371
var protoDecl = CSVariableDeclaration.VarLine (CSSimpleType.Var, returnContainerId, protoGetter);
372-
var marshalBack = CSFunctionCall.FunctionCallLine ($"{returnContainer}.CopyTo", delegateParams [0].Name);
372+
var marshalBack = CSFunctionCall.FunctionCallLine ($"{returnContainer}.CopyTo", delegateParams [1].Name);
373373
postMarshalCode.Add (protoDecl);
374374
postMarshalCode.Add (marshalBack);
375375
} else if (returnIsStruct) {
376376
// non-blitable means that the parameter is an IntPtr and we can call the
377377
// marshaler to copy into it
378378
use.AddIfNotPresent (typeof (StructMarshal));
379379
var marshalCall = CSFunctionCall.FunctionCallLine ("StructMarshal.Marshaler.ToSwift", false,
380-
invoker, delegateParams [0].Name);
380+
invoker, delegateParams [1].Name);
381381
altBody.Add (marshalCall);
382382
} else if (returnIsTuple) {
383383
// non-blitable means that the parameter is an IntPtr and we can call the
384384
// marshaler to copy into it
385385
use.AddIfNotPresent (typeof (StructMarshal));
386386
var marshalCall = CSFunctionCall.FunctionCallLine ("StructMarshal.Marshaler.ToSwift", false,
387-
invoker, delegateParams [0].Name);
387+
invoker, delegateParams [1].Name);
388388
altBody.Add (marshalCall);
389389
} else if (returnIsGeneric) {
390390
// T retval = invoker();
391391
// if (retval is ISwiftObject) {
392-
// Marshal.WriteIntPtr(delegateParams [0].Name, ((ISwiftObject)retval).SwiftObject);
392+
// Marshal.WriteIntPtr(delegateParams [1].Name, ((ISwiftObject)retval).SwiftObject);
393393
// }
394394
// else {
395-
// StructMarshal.Marshaler.ToSwift(typeof(T), retval, delegateParams[0].Name);
395+
// StructMarshal.Marshaler.ToSwift(typeof(T), retval, delegateParams[1].Name);
396396
// }
397397
string retvalName = MarshalEngine.Uniqueify ("retval", identifiersUsed);
398398
var retvalId = new CSIdentifier (retvalName);
399399
altBody.Add (CSFieldDeclaration.VarLine (methodType, retvalId, invoker));
400400
var ifClause = new CSCodeBlock ();
401401
ifClause.Add (CSFunctionCall.FunctionCallLine ("Marshal.WriteIntPtr", false,
402-
delegateParams [0].Name,
402+
delegateParams [1].Name,
403403
new CSParenthesisExpression (new CSCastExpression ("ISwiftObject", retvalId)).Dot (NewClassCompiler.kSwiftObjectGetter)));
404404
var elseClause = new CSCodeBlock ();
405405
elseClause.Add (CSFunctionCall.FunctionCallLine ("StructMarshal.Marshaler.ToSwift", false,
406406
methodType.Typeof (),
407407
retvalId,
408-
delegateParams [0].Name));
408+
delegateParams [1].Name));
409409
CSBaseExpression ifExpr = new CSSimpleType ("ISwiftObject").Typeof ().Dot (new CSFunctionCall ("IsAssignableFrom", false,
410410
methodType.Typeof ()));
411411

@@ -515,10 +515,10 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSProp (CSProperty prop, CS
515515
body.Add (CSFieldDeclaration.VarLine (methodType, retvalId, csharpCall));
516516
if (returnIsGeneric) {
517517
body.Add (CSFunctionCall.FunctionCallLine ("StructMarshal.Marshaler.ToSwift", false,
518-
methodType.Typeof (), retvalId, delegateParams [0].Name));
518+
methodType.Typeof (), retvalId, delegateParams [1].Name));
519519
} else {
520520
body.Add (CSFunctionCall.FunctionCallLine ("StructMarshal.Marshaler.ToSwift", false,
521-
retvalId, delegateParams [0].Name));
521+
retvalId, delegateParams [1].Name));
522522
}
523523
} else if (returnIsProtocol) {
524524
string retvalName = MarshalEngine.Uniqueify ("retval", identifiersUsed);
@@ -550,7 +550,7 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSProp (CSProperty prop, CS
550550
var returnContainerId = new CSIdentifier (returnContainerName);
551551
body.Add (CSVariableDeclaration.VarLine (CSSimpleType.Var, returnContainerId, new CSFunctionCall ("SwiftObjectRegistry.Registry.ExistentialContainerForProtocols", false, containerExprs.ToArray ())));
552552
body.Add (CSFunctionCall.FunctionCallLine ($"{returnContainerName}.CopyTo", false,
553-
new CSFunctionCall ("IntPtr", true, delegateParams [0].Name)));
553+
new CSFunctionCall ("IntPtr", true, delegateParams [1].Name)));
554554

555555
} else {
556556
if (returnIsClosure) {
@@ -571,16 +571,16 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSProp (CSProperty prop, CS
571571
entity = !valueIsGeneric ? typeMapper.GetEntityForTypeSpec (valueTypeSpec) : null;
572572
entityType = !valueIsGeneric ? typeMapper.GetEntityTypeForTypeSpec (funcDecl.ParameterLists [1] [0].TypeSpec) : EntityType.None;
573573
var isBoolNewValue = entityType == EntityType.Scalar && valueTypeName == "Swift.Bool";
574-
var isUnusualNewValue = IsUnusualParameter (entity, delegateParams [1]);
574+
var isUnusualNewValue = IsUnusualParameter (entity, delegateParams [2]);
575575

576576
if (entityType == EntityType.Class || (entity != null && entity.IsObjCProtocol)) {
577-
var csParmType = delegateParams [1].CSType as CSSimpleType;
577+
var csParmType = delegateParams [2].CSType as CSSimpleType;
578578
if (csParmType == null)
579579
throw ErrorHelper.CreateError (ReflectorError.kTypeMapBase + 42, "Inconceivable! The class type for a method was a CSSimpleType!");
580580
var valueIsDynamicSelf = forProtocol && methodType.ToString () == NewClassCompiler.kGenericSelfName;
581581
if (valueIsDynamicSelf) {
582582
// code generated:
583-
// var obj = SwiftObjectRegistry.Registry.CSObjectForSwiftObject<thisTypeName> (delegateParams [1].Name);
583+
// var obj = SwiftObjectRegistry.Registry.CSObjectForSwiftObject<thisTypeName> (delegateParams [2].Name);
584584
// callSite = (TSelf)(obj.xamarinImpl ?? obj)
585585
var proxObjName = MarshalEngine.Uniqueify ("proxyObj", identifiersUsed);
586586
identifiersUsed.Add (proxObjName);
@@ -591,7 +591,7 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSProp (CSProperty prop, CS
591591
} else {
592592
use.AddIfNotPresent (typeof (SwiftObjectRegistry));
593593
var fullClassName = entity.Type.ToFullyQualifiedName (true);
594-
var retrievecall = NewClassCompiler.SafeMarshalClassFromIntPtr (delegateParams [1].Name, csParmType, use, fullClassName, typeMapper, entity.IsObjCProtocol);
594+
var retrievecall = NewClassCompiler.SafeMarshalClassFromIntPtr (delegateParams [2].Name, csParmType, use, fullClassName, typeMapper, entity.IsObjCProtocol);
595595
valueExpr = retrievecall;
596596
}
597597
} else if (entityType == EntityType.Protocol) {
@@ -602,9 +602,9 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSProp (CSProperty prop, CS
602602
var ntb = typeMapper.MapType (funcDecl, funcDecl.ParameterLists [1] [0].TypeSpec, false);
603603
var valType = ntb.ToCSType (use);
604604
if (entityType == EntityType.TrivialEnum) {
605-
valueExpr = new CSCastExpression (valType, new CSCastExpression (CSSimpleType.Long, delegateParams [1].Name));
605+
valueExpr = new CSCastExpression (valType, new CSCastExpression (CSSimpleType.Long, delegateParams [2].Name));
606606
} else {
607-
var marshalCall = new CSFunctionCall ("StructMarshal.Marshaler.ToNet", false, delegateParams [1].Name, valType.Typeof ());
607+
var marshalCall = new CSFunctionCall ("StructMarshal.Marshaler.ToNet", false, delegateParams [2].Name, valType.Typeof ());
608608
valueExpr = new CSCastExpression (valType, marshalCall);
609609
}
610610
} else if (valueIsGeneric) {
@@ -614,12 +614,12 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSProp (CSProperty prop, CS
614614
var genRef = new CSGenericReferenceType (depthIndex.Item1, depthIndex.Item2);
615615
genRef.ReferenceNamer = GenericRenamer;
616616
use.AddIfNotPresent (typeof (StructMarshal));
617-
string valMarshalName = MarshalEngine.Uniqueify (delegateParams [1].Name + "Temp", identifiersUsed);
617+
string valMarshalName = MarshalEngine.Uniqueify (delegateParams [2].Name + "Temp", identifiersUsed);
618618
var valMarshalId = new CSIdentifier (valMarshalName);
619619

620620
var valDecl = CSVariableDeclaration.VarLine (genRef, valMarshalId,
621621
new CSCastExpression (genRef, new CSFunctionCall ("StructMarshal.Marshaler.ToNet", false,
622-
delegateParams [1].Name,
622+
delegateParams [2].Name,
623623
genRef.Typeof ())));
624624
body.Add (valDecl);
625625
valueExpr = valMarshalId;
@@ -631,9 +631,9 @@ public List<ICodeElement> MarshalFromLambdaReceiverToCSProp (CSProperty prop, CS
631631
flags |= ClosureFlags.Throws;
632632
if (closureReturn.IsAsync)
633633
flags |= ClosureFlags.Async;
634-
valueExpr = MarshalEngine.BuildWrappedClosureCall (delegateParams [1].Name, methodType as CSSimpleType, flags);
634+
valueExpr = MarshalEngine.BuildWrappedClosureCall (delegateParams [2].Name, methodType as CSSimpleType, flags);
635635
} else {
636-
valueExpr = delegateParams [1].Name;
636+
valueExpr = delegateParams [2].Name;
637637
if (isBoolNewValue) {
638638
valueExpr = NIntToBool (valueExpr);
639639
}

‎SwiftReflector/MarshalEngineSwiftToCSharp.cs

Lines changed: 15 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -74,6 +74,7 @@ public IEnumerable<ICodeElement> MarshalFunctionCall (FunctionDeclaration func,
7474
string throwReturnName = null;
7575
SLIdentifier throwReturn = null;
7676
SLType throwReturnType = null;
77+
var csVT = new SLIdentifier ($"{vtableName}.{OverrideBuilder.kVtableHandleName}");
7778

7879
var returnTypeSpec = TypeSpec.IsNullOrEmptyTuple (func.ReturnTypeSpec) ? func.ReturnTypeSpec : func.ReturnTypeSpec.ReplaceName ("Self", SubstituteForSelf);
7980

@@ -99,7 +100,7 @@ public IEnumerable<ICodeElement> MarshalFunctionCall (FunctionDeclaration func,
99100

100101

101102
if (func.HasThrows) {
102-
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, new CommaListElementCollection<SLBaseExpr> (closureArgs)));
103+
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, AddVTHandleAndMakeArgs (csVT, closureArgs)));
103104
string errName = MarshalEngine.Uniqueify ("err", identifiersUsed);
104105
identifiersUsed.Add (errName);
105106
var errIdent = new SLIdentifier (errName);
@@ -136,13 +137,13 @@ public IEnumerable<ICodeElement> MarshalFunctionCall (FunctionDeclaration func,
136137
// On no return value
137138
// _vtable.entry!(args)
138139
//
139-
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, new CommaListElementCollection<SLBaseExpr> (closureArgs)));
140+
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, AddVTHandleAndMakeArgs (csVT, closureArgs)));
140141
} else {
141142
if (TypeSpec.IsBuiltInValueType (returnTypeSpec)) {
142143
// on simple return types (Int, UInt, Bool, etc)
143144
// return _vtable.entry!(args)
144145
//
145-
var closureCall = new SLNamedClosureCall (callInvocation, new CommaListElementCollection<SLBaseExpr> (closureArgs));
146+
var closureCall = new SLNamedClosureCall (callInvocation, AddVTHandleAndMakeArgs (csVT, closureArgs));
146147
if (postMarshalCode.Count == 0) {
147148
returnLine = SLReturn.ReturnLine (closureCall);
148149
} else {
@@ -173,7 +174,7 @@ public IEnumerable<ICodeElement> MarshalFunctionCall (FunctionDeclaration func,
173174
SLIdentifier actualReturnIdent = new SLIdentifier (MarshalEngine.Uniqueify ("actualRetval", identifiersUsed));
174175
identifiersUsed.Add (actualReturnIdent.Name);
175176

176-
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, new CommaListElementCollection<SLBaseExpr> (closureArgs)));
177+
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, AddVTHandleAndMakeArgs (csVT, closureArgs)));
177178

178179
var actualRetvalDecl = new SLDeclaration (true, actualReturnIdent, null,
179180
new SLFunctionCall (String.Format ("{0}.move", returnIdent.Name), false),
@@ -192,7 +193,7 @@ public IEnumerable<ICodeElement> MarshalFunctionCall (FunctionDeclaration func,
192193
// return retval;
193194
imports.AddIfNotPresent ("XamGlue");
194195
SLBaseExpr callExpr = new SLFunctionCall ("fromIntPtr", false,
195-
new SLArgument (new SLIdentifier ("ptr"), new SLNamedClosureCall (callInvocation, new CommaListElementCollection<SLBaseExpr> (closureArgs)), true));
196+
new SLArgument (new SLIdentifier ("ptr"), new SLNamedClosureCall (callInvocation, AddVTHandleAndMakeArgs (csVT, closureArgs)), true));
196197
if (postMarshalCode.Count > 0) {
197198
string retvalName = MarshalEngine.Uniqueify ("retval", identifiersUsed);
198199
var retDecl = new SLDeclaration (true, retvalName,
@@ -227,7 +228,7 @@ public IEnumerable<ICodeElement> MarshalFunctionCall (FunctionDeclaration func,
227228
preMarshalCode.Add (new SLLine (ptrDecl));
228229
closureArgs.Insert (0, new SLIdentifier (ptrName));
229230

230-
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, new CommaListElementCollection<SLBaseExpr> (closureArgs)));
231+
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, AddVTHandleAndMakeArgs (csVT, closureArgs)));
231232

232233
var actualReturnName = MarshalEngine.Uniqueify ("actualReturn", identifiersUsed);
233234
identifiersUsed.Add (actualReturnName);
@@ -263,7 +264,7 @@ public IEnumerable<ICodeElement> MarshalFunctionCall (FunctionDeclaration func,
263264
SLConstant.Val (1), true)), Visibility.None);
264265
preMarshalCode.Add (new SLLine (retDecl));
265266
closureArgs.Insert (0, new SLIdentifier (retvalName));
266-
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, new CommaListElementCollection<SLBaseExpr> (closureArgs)));
267+
returnLine = new SLLine (new SLNamedClosureCall (callInvocation, AddVTHandleAndMakeArgs (csVT, closureArgs)));
267268

268269
SLIdentifier actualReturnIdent = new SLIdentifier (MarshalEngine.Uniqueify ("actualRetval", identifiersUsed));
269270
identifiersUsed.Add (actualReturnIdent.Name);
@@ -277,7 +278,6 @@ public IEnumerable<ICodeElement> MarshalFunctionCall (FunctionDeclaration func,
277278

278279
break;
279280
}
280-
281281
}
282282
}
283283
}
@@ -290,6 +290,13 @@ public IEnumerable<ICodeElement> MarshalFunctionCall (FunctionDeclaration func,
290290
yield return line;
291291
}
292292

293+
CommaListElementCollection<SLBaseExpr> AddVTHandleAndMakeArgs (SLBaseExpr csVT, List<SLBaseExpr> exprs)
294+
{
295+
var args = new CommaListElementCollection<SLBaseExpr> (exprs);
296+
args.Insert (0, csVT);
297+
return args;
298+
}
299+
293300
SLBaseExpr MarshalTypeSpec (BaseDeclaration declContext, string name, TypeSpec typeSpec)
294301
{
295302
switch (typeSpec.Kind) {

0 commit comments

Comments
 (0)