public void OperatorCompositionNoInvoke() { var swiftCode = "infix operator ∘\n" + " public func ∘<T>(left: @escaping (T) -> (T), right: @escaping (T) -> (T)) -> (T) -> (T) {\n" + " return { (x) in\n" + " left (right(x))\n" + " }\n" + "}\n"; var lbody1 = new CSCodeBlock(); var lid = new CSIdentifier("d"); lbody1.Add(CSReturn.ReturnLine(lid * CSConstant.Val(2.0))); var pl = new CSParameterList(); pl.Add(new CSParameter(CSSimpleType.Double, lid)); var lam1 = new CSLambda(pl, lbody1); var lbody2 = new CSCodeBlock(); lbody2.Add(CSReturn.ReturnLine(lid * CSConstant.Val(3.0))); var lam2 = new CSLambda(pl, lbody2); var compFunc = CSFunctionCall.FunctionCallLine("TopLevelEntities.InfixOperatorRing", false, lam1, lam2); var printIt = CSFunctionCall.ConsoleWriteLine(CSConstant.Val(12.0)); var callingCode = new CodeElementCollection <ICodeElement> { compFunc, printIt }; TestRunning.TestAndExecute(swiftCode, callingCode, "12\n"); }
public void SimpleProtocolProGetIndexer () { var swiftCode = @" public protocol Simplest4 { associatedtype Item subscript (index: Int) -> Item { get } } public func doGetIt<T:Simplest4> (a: T, i: Int) -> T.Item { return a[i] } "; var altClass = new CSClass (CSVisibility.Public, "Simple4Impl"); altClass.Inheritance.Add (new CSIdentifier ("ISimplest4<SwiftString>")); var getBlock = CSCodeBlock.Create (CSReturn.ReturnLine (new CSFunctionCall ("SwiftString.FromString", false, CSConstant.Val ("Got here!")))); var parameters = new CSParameterList (new CSParameter (new CSSimpleType ("nint"), new CSIdentifier ("index"))); var thingIndex = new CSProperty (new CSSimpleType ("SwiftString"), CSMethodKind.None, CSVisibility.Public, getBlock, CSVisibility.Public, null, parameters); altClass.Properties.Add (thingIndex); var ctor = new CSMethod (CSVisibility.Public, CSMethodKind.None, null, altClass.Name, new CSParameterList (), CSCodeBlock.Create ()); altClass.Methods.Add (ctor); var instID = new CSIdentifier ("inst"); var instDecl = CSVariableDeclaration.VarLine (instID, new CSFunctionCall ("Simple4Impl", true)); var resultID = new CSIdentifier ("result"); var resultDecl = CSVariableDeclaration.VarLine (resultID, new CSFunctionCall ("TopLevelEntities.DoGetIt<Simple4Impl, SwiftString>", false, instID, CSConstant.Val (3))); var printer = CSFunctionCall.ConsoleWriteLine (resultID); var callingCode = CSCodeBlock.Create (instDecl, resultDecl, printer); TestRunning.TestAndExecute (swiftCode, callingCode, "Got here!\n", otherClass: altClass, platform: PlatformName.macOS); }
void WrapSingleProperty(string type, string returnVal, string csType, string csReplacement, string expected) { string appendage = type.Replace('.', '_'); string swiftCode = $"open class MontyWSP{appendage} {{ public init() {{}}\n open var val: {type} {{\nget {{ return {returnVal}\n}} }} }}"; CSClass overCS = new CSClass(CSVisibility.Public, $"OverWSP{appendage}"); overCS.Inheritance.Add(new CSIdentifier($"MontyWSP{appendage}")); CSCodeBlock getterBody = CSCodeBlock.Create(CSReturn.ReturnLine(new CSIdentifier(csReplacement))); CSProperty overProp = new CSProperty(new CSSimpleType(csType), CSMethodKind.Override, new CSIdentifier("Val"), CSVisibility.Public, getterBody, CSVisibility.Public, null); overCS.Properties.Add(overProp); CSCodeBlock printBody = CSCodeBlock.Create(CSFunctionCall.ConsoleWriteLine(CSConstant.Val("{0}, {1}"), (CSIdentifier)"base.Val", (CSIdentifier)"Val")); CSMethod printIt = new CSMethod(CSVisibility.Public, CSMethodKind.None, CSSimpleType.Void, new CSIdentifier("PrintIt"), new CSParameterList(), printBody); overCS.Methods.Add(printIt); CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType($"OverWSP{appendage}"), "printer", new CSFunctionCall($"OverWSP{appendage}", true)); CSLine invoker = CSFunctionCall.FunctionCallLine("printer.PrintIt", false); CSCodeBlock callingCode = CSCodeBlock.Create(decl, invoker); TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapSingleProperty{appendage}", otherClass: overCS, platform: PlatformName.macOS); }
public void SimpleProtocolProGetSetIndexer () { var swiftCode = @" public protocol Simplest5 { associatedtype Item subscript (index: Int) -> Item { get set } } public func doSetIt<T:Simplest5> (a: inout T, i: Int, v: T.Item) { a[i] = v } "; var altClass = new CSClass (CSVisibility.Public, "Simple5Impl"); altClass.Inheritance.Add (new CSIdentifier ("ISimplest5<SwiftString>")); var fieldName = new CSIdentifier ("v"); altClass.Fields.Add (CSFieldDeclaration.FieldLine (new CSSimpleType ("SwiftString"), fieldName)); var getBlock = CSCodeBlock.Create (CSReturn.ReturnLine (fieldName)); var setBlock = CSCodeBlock.Create (CSAssignment.Assign (fieldName, new CSIdentifier ("value"))); var parameters = new CSParameterList (new CSParameter (new CSSimpleType ("nint"), new CSIdentifier ("index"))); var thingIndex = new CSProperty (new CSSimpleType ("SwiftString"), CSMethodKind.None, CSVisibility.Public, getBlock, CSVisibility.Public, setBlock, parameters); altClass.Properties.Add (thingIndex); var ctor = new CSMethod (CSVisibility.Public, CSMethodKind.None, null, altClass.Name, new CSParameterList (), CSCodeBlock.Create ()); altClass.Methods.Add (ctor); var instID = new CSIdentifier ("inst"); var instDecl = CSVariableDeclaration.VarLine (instID, new CSFunctionCall ("Simple5Impl", true)); var callSetter = CSFunctionCall.FunctionCallLine ("TopLevelEntities.DoSetIt", false, instID, CSConstant.Val (3), new CSFunctionCall ("SwiftString.FromString", false, CSConstant.Val ("Got here!"))); var printer = CSFunctionCall.ConsoleWriteLine (new CSIdentifier ($"{instID.Name}[3]")); var callingCode = CSCodeBlock.Create (instDecl, callSetter, printer); TestRunning.TestAndExecute (swiftCode, callingCode, "Got here!\n", otherClass: altClass, platform: PlatformName.macOS); }
void WrapSingleSubscriptGetOnly(string type, string csType, string csReplacement, string csAlt, string expected) { string swiftCode = TestRunningCodeGenerator.kSwiftFileWriter + $"public protocol MontyWSGO{type} {{ subscript(i:Int32) -> {type} {{ get }} \n }}\n" + $"public class TestMontyWSGO{type} {{\npublic init() {{ }}\npublic func doIt(m:MontyWSGO{type}) {{\nvar s = \"\", t=\"\"\nprint(m[0], to:&s)\nprint(m[1], to:&t)\nwriteToFile(s+t, \"WrapSingleSubscriptGetOnly{type}\")\n}}\n}}\n"; CSClass overCS = new CSClass(CSVisibility.Public, $"OverWSGO{type}"); overCS.Inheritance.Add(new CSIdentifier($"IMontyWSGO{type}")); CSParameterList overParams = new CSParameterList(); overParams.Add(new CSParameter(CSSimpleType.Int, "i")); CSCodeBlock overBody = CSCodeBlock.Create(CSReturn.ReturnLine(new CSTernary(new CSIdentifier("i") == CSConstant.Val(0), new CSIdentifier(csReplacement), new CSIdentifier(csAlt), false))); CSProperty overProp = new CSProperty(new CSSimpleType(csType), CSMethodKind.None, CSVisibility.Public, overBody, CSVisibility.Public, null, overParams); overCS.Properties.Add(overProp); CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType($"OverWSGO{type}"), "myOver", new CSFunctionCall($"OverWSGO{type}", true)); CSLine decl1 = CSVariableDeclaration.VarLine(new CSSimpleType($"TestMontyWSGO{type}"), "tester", new CSFunctionCall($"TestMontyWSGO{type}", true)); CSLine invoker = CSFunctionCall.FunctionCallLine("tester.DoIt", false, new CSIdentifier("myOver")); CSCodeBlock callingCode = CSCodeBlock.Create(decl, decl1, invoker); TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapSingleSubscriptGetOnly{type}", otherClass: overCS); }
public void SimplestProtocolPropGetAssocTest () { var swiftCode = @" public protocol Simplest1 { associatedtype Item var printThing: Item { get } } public func doPrint<T>(a:T) where T:Simplest1 { let _ = a.printThing } "; var altClass = new CSClass (CSVisibility.Public, "Simple1Impl"); altClass.Inheritance.Add (new CSIdentifier ("ISimplest1<SwiftString>")); var strID = new CSIdentifier ("theStr"); var strDecl = CSVariableDeclaration.VarLine (strID, CSConstant.Val ("Got here!")); var printPart = CSFunctionCall.ConsoleWriteLine (strID); var returnPart = CSReturn.ReturnLine (new CSFunctionCall ("SwiftString.FromString", false, strID)); var printBody = CSCodeBlock.Create (strDecl, printPart, returnPart); var speak = new CSProperty (new CSSimpleType ("SwiftString"), CSMethodKind.None, new CSIdentifier ("PrintThing"), CSVisibility.Public, printBody, CSVisibility.Public, null); altClass.Properties.Add (speak); var ctor = new CSMethod (CSVisibility.Public, CSMethodKind.None, null, altClass.Name, new CSParameterList (), CSCodeBlock.Create ()); altClass.Methods.Add (ctor); var instID = new CSIdentifier ("inst"); var instDecl = CSVariableDeclaration.VarLine (instID, new CSFunctionCall ("Simple1Impl", true)); var doPrint = CSFunctionCall.FunctionCallLine ("TopLevelEntities.DoPrint<Simple1Impl, SwiftString>", false, instID); var callingCode = CSCodeBlock.Create (instDecl, doPrint); TestRunning.TestAndExecute (swiftCode, callingCode, "Got here!\n", otherClass: altClass, platform: PlatformName.macOS); }
static CSProperty MakeGetOnlyStringProp(string name, string val) { CSCodeBlock body = new CSCodeBlock(); body.Add(CSReturn.ReturnLine(CSConstant.Val(val))); return(new CSProperty(CSSimpleType.String, CSMethodKind.None, new CSIdentifier(name), CSVisibility.Public, body, CSVisibility.Public, null)); }
public void StaticMethodParam() { using (Stream stm = Utils.BasicClass("None", "AClass", null, cl => { CSParameterList pl = new CSParameterList().And(new CSParameter(CSSimpleType.Int, "x")); CSCodeBlock b = new CSCodeBlock().And(CSReturn.ReturnLine(CSConstant.Val(0))); cl.Methods.Add(CSMethod.PublicMethod(CSMethodKind.Virtual, CSSimpleType.Int, "Foo", pl, b)); return(cl); })) { Utils.CompileAStream(stm); } }
public void NSObjectSubclassableMethodTest3() { string swiftCode = "import Foundation\n" + "@objc\n" + "open class Subclassable3 : NSObject {\n" + " public override init () { }\n" + " open var returnsTrue:Bool {\n" + " get { return true\n } " + " }\n" + "}\n" + "public func callIt (a: Subclassable3) -> Bool {\n" + " return a.returnsTrue\n" + "}\n"; var theSub = new CSClass(CSVisibility.Public, "TheSub3"); var ctor = new CSMethod(CSVisibility.Public, CSMethodKind.None, null, theSub.Name, new CSParameterList(), new CSBaseExpression [0], true, new CSCodeBlock()); theSub.Constructors.Add(ctor); theSub.Inheritance.Add(new CSIdentifier("Subclassable3")); var theBody = new CSCodeBlock(); theBody.Add(CSReturn.ReturnLine(CSConstant.Val(false))); LineCodeElementCollection <ICodeElement> getCode = new LineCodeElementCollection <ICodeElement> ( new ICodeElement [] { CSReturn.ReturnLine(CSConstant.Val(false)) }, false, true); CSProperty returnsFalse = new CSProperty(CSSimpleType.Bool, CSMethodKind.Override, new CSIdentifier("ReturnsTrue"), CSVisibility.Public, new CSCodeBlock(getCode), CSVisibility.Public, null); theSub.Properties.Add(returnsFalse); var callingCode = new CodeElementCollection <ICodeElement> (); var objID = new CSIdentifier("subTest"); var objDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, objID, new CSFunctionCall("TheSub3", true)); var call = CSFunctionCall.ConsoleWriteLine(objID.Dot((CSIdentifier)"ReturnsTrue")); var call2 = CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Function("TopLevelEntities.CallIt", objID)); callingCode.Add(objDecl); callingCode.Add(call); callingCode.Add(call2); TestRunning.TestAndExecute(swiftCode, callingCode, "False\nFalse\n", otherClass: theSub, platform: PlatformName.macOS); }
void ClosureConstantFunc(string appendage, string swiftType, string csVal, string output, bool escaping) { appendage += escaping.ToString(); string escapingAttribute = escaping ? "@escaping" : ""; string swiftCode = $"public func callClosureCCF{appendage}(f:{escapingAttribute}()->{swiftType}) -> {swiftType} {{\n" + " return f()\n" + "}"; CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); CSCodeBlock body = new CSCodeBlock(); body.Add(CSReturn.ReturnLine(new CSIdentifier(csVal))); CSLine invoker = CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Function($"TopLevelEntities.CallClosureCCF{appendage}", new CSLambda(body))); callingCode.Add(invoker); TestRunning.TestAndExecute(swiftCode, callingCode, output, testName: $"ClosureConstantFunc{appendage}"); }
void ClosureSumFunc(string swiftType, string csVal1, string csVal2, string output, bool escaping) { string escapingAttribute = escaping ? "@escaping" : ""; string swiftCode = $"public func sumIt{swiftType}{escaping}(a:{swiftType}, b:{swiftType}, f:{escapingAttribute}({swiftType},{swiftType})->{swiftType}) -> {swiftType} {{\n" + " return f(a, b)\n" + "}"; CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); CSCodeBlock body = new CSCodeBlock(); body.Add(CSReturn.ReturnLine(new CSIdentifier("val1") + new CSIdentifier("val2"))); CSLine invoker = CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Function($"TopLevelEntities.SumIt{swiftType}{escaping}", (CSIdentifier)csVal1, (CSIdentifier)csVal2, new CSLambda(body, "val1", "val2"))); callingCode.Add(invoker); TestRunning.TestAndExecute(swiftCode, callingCode, output, testName: $"ClosureSumFunc{swiftType}{escaping}"); }
public void TestSimplest() { var swiftCode = @" public protocol Identity1 { func whoAmI () -> Self } public func getName (a: Identity1) -> String { let o = a.whoAmI let t = type(of: o) return String(describing: t) } "; // public class Foo : Identity1<Foo> // { // public Foo () { } // public Foo WhoAmI () { // return this; // } // } var auxClass = new CSClass(CSVisibility.Public, "Foo"); auxClass.Inheritance.Add(new CSIdentifier("IIdentity1<Foo>")); var ctor = new CSMethod(CSVisibility.Public, CSMethodKind.None, null, auxClass.Name, new CSParameterList(), new CSCodeBlock()); var whoAmI = new CSMethod(CSVisibility.Public, CSMethodKind.None, new CSSimpleType(auxClass.Name.Name), new CSIdentifier("WhoAmI"), new CSParameterList(), CSCodeBlock.Create(CSReturn.ReturnLine(CSIdentifier.This))); auxClass.Constructors.Add(ctor); auxClass.Methods.Add(whoAmI); var instName = new CSIdentifier("inst"); var nameName = new CSIdentifier("name"); var instDecl = CSVariableDeclaration.VarLine(instName, new CSFunctionCall(auxClass.Name, new Dynamo.CommaListElementCollection <CSBaseExpression> (), true)); var nameDecl = CSVariableDeclaration.VarLine(nameName, new CSFunctionCall("TopLevelEntities.GetName", false, instName)); var printer = CSFunctionCall.ConsoleWriteLine(nameName); var callingCode = CSCodeBlock.Create(instDecl, nameDecl, printer); TestRunning.TestAndExecute(swiftCode, callingCode, "() -> Identity1\n", otherClass: auxClass, platform: PlatformName.macOS); }
void VirtualMethodException(string toAdd, string output) { string swiftCode = $"public enum MyErrorVME{toAdd} : Error {{\ncase itFailed\n}}\n" + $"open class FooVME{toAdd} {{\npublic init() {{\n}}\n public final func doIt(doThrow:Bool) throws {{\n let _ = try throwIt(doThrow:doThrow)\n}}\n open func throwIt(doThrow: Bool) throws -> Int\n {{\n if doThrow {{\n throw MyErrorVME{toAdd}.itFailed\n}}\nelse {{\n return 5\n}}\n}}\n}}\n"; CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); CSClass fooOver = new CSClass(CSVisibility.Public, $"SubFooVME{toAdd}"); fooOver.Inheritance.Add(new CSIdentifier($"FooVME{toAdd}")); CSCodeBlock overBody = new CSCodeBlock(); CSCodeBlock ifblock = new CSCodeBlock(); CSCodeBlock elseblock = new CSCodeBlock(); ifblock.Add(new CSLine(new CSThrow(new CSFunctionCall("ArgumentException", true, CSConstant.Val("gotcha."))))); elseblock.Add(CSReturn.ReturnLine(CSConstant.Val(6))); CSIfElse ifElse = new CSIfElse(new CSIdentifier("doThrow"), ifblock, elseblock); overBody.Add(ifElse); CSMethod myThrowIt = new CSMethod(CSVisibility.Public, CSMethodKind.Override, new CSSimpleType("nint"), new CSIdentifier("ThrowIt"), new CSParameterList(new CSParameter(CSSimpleType.Bool, new CSIdentifier("doThrow"))), overBody); fooOver.Methods.Add(myThrowIt); CSCodeBlock tryBlock = new CSCodeBlock(); CSLine varLine = CSVariableDeclaration.VarLine(new CSSimpleType($"SubFooVME{toAdd}"), "foo", new CSFunctionCall($"SubFooVME{toAdd}", true)); tryBlock.Add(varLine); CSLine call = CSFunctionCall.FunctionCallLine("foo.DoIt", false, new CSIdentifier(toAdd)); tryBlock.Add(call); CSCodeBlock catchBlock = new CSCodeBlock(); catchBlock.Add(CSFunctionCall.FunctionCallLine("Console.Write", false, new CSIdentifier("e").Dot(new CSIdentifier("Message")))); CSTryCatch catcher = new CSTryCatch(tryBlock, typeof(SwiftException), "e", catchBlock); callingCode.Add(catcher); TestRunning.TestAndExecute(swiftCode, callingCode, output, testName: $"VirtualMethodException{toAdd}", otherClass: fooOver, platform: PlatformName.macOS); }
public void HandlesAutoclosure() { var swiftCode = "public func autoClosureCheck(a: @autoclosure ()->Bool) -> Bool {\n" + " return a()\n" + "}\n"; var callingCode = new CodeElementCollection <ICodeElement> (); var body = new CSCodeBlock(); body.Add(CSReturn.ReturnLine(CSConstant.Val(true))); var lambda = new CSLambda(body); var printer = CSFunctionCall.ConsoleWriteLine(CSFunctionCall.Function("TopLevelEntities.AutoClosureCheck", lambda)); callingCode.Add(printer); TestRunning.TestAndExecute(swiftCode, callingCode, "True\n"); }
public void CustomStringConvertibleTest() { var swiftCode = TestRunningCodeGenerator.kSwiftFileWriter + "public func printIt(a: CustomStringConvertible) {\n" + " writeToFile(a.description, \"CustomStringConvertibleTest\")\n" + "}\n"; var convertible = new CSClass(CSVisibility.Public, "MyConvert"); convertible.Inheritance.Add(new CSIdentifier("ICustomStringConvertible")); var getBody = CSCodeBlock.Create(CSReturn.ReturnLine(new CSFunctionCall("SwiftString.FromString", false, CSConstant.Val("I did it!")))); var declProp = new CSProperty(new CSSimpleType(typeof(SwiftString)), CSMethodKind.None, new CSIdentifier("Description"), CSVisibility.Public, getBody, CSVisibility.Public, null); convertible.Properties.Add(declProp); var caller = CSFunctionCall.FunctionCallLine("TopLevelEntities.PrintIt", false, new CSFunctionCall("MyConvert", true)); var callingCode = CSCodeBlock.Create(caller); TestRunning.TestAndExecute(swiftCode, callingCode, "I did it!", otherClass: convertible); }
void MakeCapsuleAccessor(CSClass cl) { CSParameterList pl = new CSParameterList(); pl.Add(new CSParameter(new CSSimpleType(typeof(EventArgs)), "evt")); CSCodeBlock body = new CSCodeBlock(); // System.Reflection.PropertyInfo pi = evt.GetType().GetProperty("Capsule"); // return pi.GetValue(evt); body.Add(CSVariableDeclaration.VarLine(new CSSimpleType("System.Reflection.PropertyInfo"), "pi", new CSFunctionCall("evt.GetType().GetProperty", false, CSConstant.Val("Capsule")))); body.Add(CSReturn.ReturnLine(new CSFunctionCall("pi.GetValue", false, new CSIdentifier("evt")))); CSMethod meth = new CSMethod(CSVisibility.Public, CSMethodKind.None, CSSimpleType.Object, new CSIdentifier("GetCapsule"), pl, body); cl.Methods.Add(meth); }
public CSProperty CompileProperty(string propertyName, CSUsingPackages packs, SwiftType swiftPropertyType, bool hasGetter, bool hasSetter, CSMethodKind methodKind) { propertyName = typeMap.SanitizeIdentifier(propertyName); NetTypeBundle propertyType = typeMap.MapType(swiftPropertyType, false); if (!(swiftPropertyType is SwiftGenericArgReferenceType)) { AddUsingBlock(packs, propertyType); } ICodeElement [] uselessLine = new ICodeElement [] { CSReturn.ReturnLine(new CSIdentifier("useless")) }; CSCodeBlock getterBlock = null; if (hasGetter) { getterBlock = new CSCodeBlock(uselessLine); } CSCodeBlock setterBlock = null; if (hasSetter) { setterBlock = new CSCodeBlock(uselessLine); } CSProperty theProp = new CSProperty(propertyType.ToCSType(packs), methodKind, new CSIdentifier(propertyName), CSVisibility.Public, getterBlock, CSVisibility.Public, setterBlock); if (getterBlock != null) { getterBlock.Clear(); } if (setterBlock != null) { setterBlock.Clear(); } return(theProp); }
public void ClosureIdentityIntBool() { var swiftCode = "public func closureIdentityIntBool(a: @escaping (Int) -> Bool) -> (Int) -> (Bool) {\n" + " return a\n" + "}\n"; var callingCode = new CodeElementCollection <ICodeElement> (); var body = new CSCodeBlock(); body.Add(CSFunctionCall.ConsoleWriteLine((CSIdentifier)"i")); body.Add(CSReturn.ReturnLine(CSConstant.Val(true))); var lambda = new CSLambda(body, "i"); var returnType = new CSSimpleType("Func", false, new CSSimpleType("nint"), CSSimpleType.Bool); callingCode.Add(CSVariableDeclaration.VarLine(returnType, "lam", lambda)); callingCode.Add(CSVariableDeclaration.VarLine(returnType, "lamreturn", new CSFunctionCall("TopLevelEntities.ClosureIdentityIntBool", false, new CSIdentifier("lam")))); callingCode.Add(CSFunctionCall.FunctionCallLine("lamreturn", false, CSConstant.Val(17))); TestRunning.TestAndExecute(swiftCode, callingCode, "17\n"); }
void WrapSingleMethod(string type, string csType, string csReplacement, string expected) { string swiftCode = TestRunningCodeGenerator.kSwiftFileWriter + $"public protocol MontyWSM{type} {{ func val() -> {type}\n }}\n" + $"public class TestMontyWSM{type} {{\npublic init() {{ }}\npublic func doIt(m:MontyWSM{type}) {{\nvar s = \"\"\nprint(m.val(), to:&s)\nwriteToFile(s, \"WrapSingleMethod{type}\")\n}}\n}}\n"; CSClass overCS = new CSClass(CSVisibility.Public, $"OverWSM{type}"); overCS.Inheritance.Add(new CSIdentifier($"IMontyWSM{type}")); CSCodeBlock overBody = CSCodeBlock.Create(CSReturn.ReturnLine(new CSIdentifier(csReplacement))); CSMethod overMeth = new CSMethod(CSVisibility.Public, CSMethodKind.None, new CSSimpleType(csType), new CSIdentifier("Val"), new CSParameterList(), overBody); overCS.Methods.Add(overMeth); CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType($"OverWSM{type}"), "myOver", new CSFunctionCall($"OverWSM{type}", true)); CSLine decl1 = CSVariableDeclaration.VarLine(new CSSimpleType($"TestMontyWSM{type}"), "tester", new CSFunctionCall($"TestMontyWSM{type}", true)); CSLine invoker = CSFunctionCall.FunctionCallLine("tester.DoIt", false, new CSIdentifier("myOver")); CSCodeBlock callingCode = CSCodeBlock.Create(decl, decl1, invoker); TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapSingleMethod{type}", otherClass: overCS, platform: PlatformName.macOS); }
void WrapClassCallsVirtual(string type, string returnVal, string csType, string csReplacement, string expected) { string safeType = type.Replace('.', '_'); string swiftCode = TestRunningCodeGenerator.kSwiftFileWriter + $"open class HolderWCCV{safeType} {{ public init() {{}}\n open func val() -> {type} {{ return {returnVal}; }} }}\n" + $"public final class FooWVVC{safeType} {{ var holder:HolderWCCV{safeType}\npublic init(h:HolderWCCV{safeType}) {{ holder = h\n}}\npublic func doIt() {{ var s = \"\"\nprint(holder.val(), to:&s);\nwriteToFile(s, \"WrapClassCallsVirtual{safeType}\")\n }} }}"; CSClass overCS = new CSClass(CSVisibility.Public, $"OverWCCV{safeType}"); overCS.Inheritance.Add(new CSIdentifier($"HolderWCCV{safeType}")); CSCodeBlock overBody = CSCodeBlock.Create(CSReturn.ReturnLine(new CSIdentifier(csReplacement))); CSMethod overMeth = new CSMethod(CSVisibility.Public, CSMethodKind.Override, new CSSimpleType(csType), new CSIdentifier("Val"), new CSParameterList(), overBody); overCS.Methods.Add(overMeth); CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); callingCode.Add(CSVariableDeclaration.VarLine(new CSSimpleType($"FooWVVC{safeType}"), "foo", new CSFunctionCall($"FooWVVC{safeType}", true, new CSFunctionCall($"OverWCCV{safeType}", true)))); callingCode.Add(CSFunctionCall.FunctionCallLine("foo.DoIt", false)); TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapClassCallsVirtual{safeType}", otherClass: overCS, platform: PlatformName.macOS); }
void WrapSingleMethod(string type, string returnVal, string csType, string csReplacement, string expected) { string swiftCode = $"open class MontyWSM{type} {{ public init() {{}}\n open func val() -> {type} {{ return {returnVal}; }} }}"; CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> (); CSClass overCS = new CSClass(CSVisibility.Public, $"OverWSM{type}"); overCS.Inheritance.Add(new CSIdentifier($"MontyWSM{type}")); CSCodeBlock overBody = CSCodeBlock.Create(CSReturn.ReturnLine(new CSIdentifier(csReplacement))); CSMethod overMeth = new CSMethod(CSVisibility.Public, CSMethodKind.Override, new CSSimpleType(csType), new CSIdentifier("Val"), new CSParameterList(), overBody); overCS.Methods.Add(overMeth); CSCodeBlock printBody = CSCodeBlock.Create(CSFunctionCall.ConsoleWriteLine(CSConstant.Val("{0}, {1}"), CSFunctionCall.Function("base.Val"), CSFunctionCall.Function("Val"))); CSMethod printIt = new CSMethod(CSVisibility.Public, CSMethodKind.None, CSSimpleType.Void, new CSIdentifier("PrintIt"), new CSParameterList(), printBody); overCS.Methods.Add(printIt); callingCode.Add(CSVariableDeclaration.VarLine(new CSSimpleType($"OverWSM{type}"), "printer", new CSFunctionCall($"OverWSM{type}", true))); callingCode.Add(CSFunctionCall.FunctionCallLine("printer.PrintIt", false)); TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapSingleMethod{type}", otherClass: overCS, platform: PlatformName.macOS); }
void WrapSinglePropertyGetOnly(string appendage, string type, string csType, string csReplacement, string expected) { string swiftCode = TestRunningCodeGenerator.kSwiftFileWriter + $"public protocol MontyWSPGO{type} {{ var prop : {type} {{ get }} \n }}\n" + $"public class TestMontyWSPGO{type} {{\npublic init() {{ }}\npublic func doIt(m:MontyWSPGO{type}) {{\nvar s = \"\"\nprint(m.prop, to:&s)\nwriteToFile(s, \"WrapSinglePropertyGetOnly{appendage}\")\n}}\n}}\n"; CSClass overCS = new CSClass(CSVisibility.Public, $"OverWSPGO{type}"); overCS.Inheritance.Add(new CSIdentifier($"IMontyWSPGO{type}")); CSCodeBlock overBody = CSCodeBlock.Create(CSReturn.ReturnLine(new CSIdentifier(csReplacement))); CSProperty overProp = new CSProperty(new CSSimpleType(csType), CSMethodKind.None, new CSIdentifier("Prop"), CSVisibility.Public, overBody, CSVisibility.Public, null); overCS.Properties.Add(overProp); CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType($"OverWSPGO{type}"), "myOver", new CSFunctionCall($"OverWSPGO{type}", true)); CSLine decl1 = CSVariableDeclaration.VarLine(new CSSimpleType($"TestMontyWSPGO{type}"), "tester", new CSFunctionCall($"TestMontyWSPGO{type}", true)); CSLine invoker = CSFunctionCall.FunctionCallLine("tester.DoIt", false, new CSIdentifier("myOver")); CSCodeBlock callingCode = CSCodeBlock.Create(decl, decl1, invoker); TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapSinglePropertyGetOnly{appendage}", otherClass: overCS, platform: PlatformName.macOS); }
public void ClosureIdentityDoubleDoubleDouble() { var swiftCode = "public func closureIdentityDoubleDoubleDouble(a: @escaping (Double, Double) -> Double) -> (Double, Double) -> Double {\n" + " return a\n" + "}\n"; var callingCode = new CodeElementCollection <ICodeElement> (); var body = new CSCodeBlock(); var aId = new CSIdentifier("a"); var bId = new CSIdentifier("b"); body.Add(CSFunctionCall.ConsoleWriteLine(aId + bId)); body.Add(CSReturn.ReturnLine(aId + bId)); var lambda = new CSLambda(body, "a", "b"); var returnType = new CSSimpleType("Func", false, CSSimpleType.Double, CSSimpleType.Double, CSSimpleType.Double); callingCode.Add(CSVariableDeclaration.VarLine(returnType, "lam", lambda)); callingCode.Add(CSVariableDeclaration.VarLine(returnType, "lamreturn", new CSFunctionCall("TopLevelEntities.ClosureIdentityDoubleDoubleDouble", false, new CSIdentifier("lam")))); callingCode.Add(CSFunctionCall.FunctionCallLine("lamreturn", false, CSConstant.Val(3.1), CSConstant.Val(4.0))); TestRunning.TestAndExecute(swiftCode, callingCode, "7.1\n"); }
public List <ICodeElement> MarshalFromLambdaReceiverToCSProp(CSProperty prop, CSType thisType, string csProxyName, CSParameterList delegateParams, FunctionDeclaration funcDecl, CSType methodType, bool isObjC) { bool forProtocol = csProxyName != null; bool needsReturn = funcDecl.IsGetter; bool returnIsGeneric = funcDecl.IsTypeSpecGeneric(funcDecl.ReturnTypeSpec); var entity = !returnIsGeneric?typeMapper.GetEntityForTypeSpec(funcDecl.ReturnTypeSpec) : null; var entityType = !returnIsGeneric?typeMapper.GetEntityTypeForTypeSpec(funcDecl.ReturnTypeSpec) : EntityType.None; bool returnIsStructOrEnum = needsReturn && entity != null && entity.IsStructOrEnum; bool returnIsClass = needsReturn && entity != null && entity.EntityType == EntityType.Class; bool returnIsProtocol = needsReturn && entity != null && entity.EntityType == EntityType.Protocol; bool returnIsProtocolList = needsReturn && entityType == EntityType.ProtocolList; bool returnIsTuple = needsReturn && entityType == EntityType.Tuple; bool returnIsClosure = needsReturn && entityType == EntityType.Closure; string returnCsProxyName = returnIsProtocol ? NewClassCompiler.CSProxyNameForProtocol(entity.Type.ToFullyQualifiedName(true), typeMapper) : null; if (returnIsProtocol && returnCsProxyName == null) { throw ErrorHelper.CreateError(ReflectorError.kCompilerReferenceBase + 22, $"Unable to find C# interface for protocol {entity.Type.ToFullyQualifiedName ()}"); } var body = new List <ICodeElement> (); if (isObjC) { use.AddIfNotPresent("ObjCRuntime"); } else { use.AddIfNotPresent(typeof(SwiftObjectRegistry)); } CSIdentifier csharpCall = null; if (forProtocol) { csharpCall = new CSIdentifier($"SwiftObjectRegistry.Registry.InterfaceForExistentialContainer<{thisType.ToString()}> (self).{prop.Name.Name}"); } else { var call = isObjC ? $"ObjCRuntime.Runtime.GetNSObject<{thisType.ToString ()}> (self).{prop.Name.Name}" : $"SwiftObjectRegistry.Registry.CSObjectForSwiftObject<{thisType.ToString ()}> (self).{prop.Name.Name}"; csharpCall = new CSIdentifier(call); } if (funcDecl.IsGetter) { if (returnIsClass) { if (isObjC) { body.Add(CSReturn.ReturnLine(csharpCall.Dot(new CSIdentifier("Handle")))); } else { body.Add(CSReturn.ReturnLine(csharpCall.Dot(NewClassCompiler.kSwiftObjectGetter))); } } else if (returnIsStructOrEnum || returnIsTuple || returnIsGeneric) { use.AddIfNotPresent(typeof(StructMarshal)); string retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); var retvalId = new CSIdentifier(retvalName); body.Add(CSFieldDeclaration.VarLine(methodType, retvalId, csharpCall)); if (returnIsGeneric) { body.Add(CSFunctionCall.FunctionCallLine("StructMarshal.Marshaler.ToSwift", false, methodType.Typeof(), retvalId, delegateParams [0].Name)); } else { body.Add(CSFunctionCall.FunctionCallLine("StructMarshal.Marshaler.ToSwift", false, retvalId, delegateParams [0].Name)); } } else if (returnIsProtocol) { string retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); identifiersUsed.Add(retvalName); var retvalId = new CSIdentifier(retvalName); body.Add(CSFieldDeclaration.VarLine(methodType, retvalId, csharpCall)); var protocolMaker = new CSFunctionCall("SwiftExistentialContainer1", true, new CSFunctionCall("SwiftObjectRegistry.Registry.ExistentialContainerForProtocols", false, retvalId, methodType.Typeof())); body.Add(CSReturn.ReturnLine(protocolMaker)); } else if (returnIsProtocolList) { var protoTypeOf = new List <CSBaseExpression> (); var swiftProtoList = funcDecl.ReturnTypeSpec as ProtocolListTypeSpec; foreach (var swiftProto in swiftProtoList.Protocols.Keys) { protoTypeOf.Add(typeMapper.MapType(funcDecl, swiftProto, false).ToCSType(use).Typeof()); } var callExprs = new List <CSBaseExpression> (); callExprs.Add(csharpCall); callExprs.AddRange(protoTypeOf); var retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); identifiersUsed.Add(retvalName); var retvalId = new CSIdentifier(retvalName); body.Add(CSVariableDeclaration.VarLine(methodType, retvalId, new CSFunctionCall("StructMarshal.ThrowIfNotImplementsAll", false, callExprs.ToArray()))); var containerExprs = new List <CSBaseExpression> (); containerExprs.Add(retvalId); containerExprs.AddRange(protoTypeOf); var returnContainerName = MarshalEngine.Uniqueify("returnContainer", identifiersUsed); identifiersUsed.Add(returnContainerName); var returnContainerId = new CSIdentifier(returnContainerName); body.Add(CSVariableDeclaration.VarLine(CSSimpleType.Var, returnContainerId, new CSFunctionCall("SwiftObjectRegistry.Registry.ExistentialContainerForProtocols", false, containerExprs.ToArray()))); body.Add(CSFunctionCall.FunctionCallLine($"{returnContainerName}.CopyTo", false, new CSUnaryExpression(CSUnaryOperator.Ref, delegateParams [0].Name))); } else { if (returnIsClosure) { body.Add(CSReturn.ReturnLine(MarshalEngine.BuildBlindClosureCall(csharpCall, methodType as CSSimpleType, use))); } else { body.Add(CSReturn.ReturnLine(csharpCall)); } } } else { CSBaseExpression valueExpr = null; bool valueIsGeneric = funcDecl.IsTypeSpecGeneric(funcDecl.ParameterLists [1] [0].TypeSpec); entity = !valueIsGeneric?typeMapper.GetEntityForTypeSpec(funcDecl.ParameterLists [1] [0].TypeSpec) : null; entityType = !valueIsGeneric?typeMapper.GetEntityTypeForTypeSpec(funcDecl.ParameterLists [1] [0].TypeSpec) : EntityType.None; var isUnusualNewValue = IsUnusualParameter(entity, delegateParams [1]); if (entityType == EntityType.Class || (entity != null && entity.IsObjCProtocol)) { var csParmType = delegateParams [1].CSType as CSSimpleType; if (csParmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 42, "Inconceivable! The class type for a method was a CSSimpleType!"); } use.AddIfNotPresent(typeof(SwiftObjectRegistry)); var fullClassName = entity.Type.ToFullyQualifiedName(true); var retrievecall = NewClassCompiler.SafeMarshalClassFromIntPtr(delegateParams [1].Name, csParmType, use, fullClassName, typeMapper, entity.IsObjCProtocol); valueExpr = retrievecall; } else if (entityType == EntityType.Protocol) { use.AddIfNotPresent(typeof(SwiftObjectRegistry)); var retrievecall = new CSFunctionCall($"SwiftObjectRegistry.Registry.InterfaceForExistentialContainer<{thisType.ToString ()}> (self).{prop.Name.Name}", false); valueExpr = retrievecall; } else if (entityType == EntityType.Tuple || (entity != null && entity.IsStructOrEnum && !isUnusualNewValue)) { var ntb = typeMapper.MapType(funcDecl, funcDecl.ParameterLists [1] [0].TypeSpec, false); var valType = ntb.ToCSType(use); if (entityType == EntityType.TrivialEnum) { valueExpr = new CSCastExpression(valType, new CSCastExpression(CSSimpleType.Long, delegateParams [1].Name)); } else { var marshalCall = new CSFunctionCall("StructMarshal.Marshaler.ToNet", false, delegateParams [1].Name, valType.Typeof()); valueExpr = new CSCastExpression(valType, marshalCall); } } else if (valueIsGeneric) { // T someVal = (T)StructMarshal.Marshaler.ToNet(parm, typeof(T)); // someVal gets passed in var depthIndex = funcDecl.GetGenericDepthAndIndex(funcDecl.ParameterLists [1] [0].TypeSpec); var genRef = new CSGenericReferenceType(depthIndex.Item1, depthIndex.Item2); use.AddIfNotPresent(typeof(StructMarshal)); string valMarshalName = MarshalEngine.Uniqueify(delegateParams [1].Name + "Temp", identifiersUsed); var valMarshalId = new CSIdentifier(valMarshalName); var valDecl = CSVariableDeclaration.VarLine(genRef, valMarshalId, new CSCastExpression(genRef, new CSFunctionCall("StructMarshal.Marshaler.ToNet", false, delegateParams [1].Name, genRef.Typeof()))); body.Add(valDecl); valueExpr = valMarshalId; } else { if (entityType == EntityType.Closure) { valueExpr = MarshalEngine.BuildWrappedClosureCall(delegateParams [1].Name, methodType as CSSimpleType); } else { valueExpr = delegateParams [1].Name; } } body.Add(CSAssignment.Assign(csharpCall, valueExpr)); } return(body); }
public List <ICodeElement> MarshalFromLambdaReceiverToCSFunc(CSType thisType, string csProxyName, CSParameterList delegateParams, FunctionDeclaration funcDecl, CSType methodType, CSParameterList methodParams, string methodName, bool isObjC) { bool thisIsInterface = csProxyName != null; bool isIndexer = funcDecl.IsSubscript; bool needsReturn = methodType != null && methodType != CSSimpleType.Void; bool isSetter = funcDecl.IsSubscriptSetter; bool returnIsGeneric = funcDecl.IsTypeSpecGeneric(funcDecl.ReturnTypeSpec); var entity = !returnIsGeneric?typeMapper.GetEntityForTypeSpec(funcDecl.ReturnTypeSpec) : null; var returnEntity = entity; var entityType = !returnIsGeneric?typeMapper.GetEntityTypeForTypeSpec(funcDecl.ReturnTypeSpec) : EntityType.None; bool returnIsStruct = needsReturn && entity != null && entity.IsStructOrEnum; bool returnIsClass = needsReturn && entity != null && entity.EntityType == EntityType.Class; bool returnIsProtocol = needsReturn && ((entity != null && entity.EntityType == EntityType.Protocol) || entityType == EntityType.ProtocolList); bool returnIsTuple = needsReturn && entityType == EntityType.Tuple; bool returnIsClosure = needsReturn && entityType == EntityType.Closure; var callParams = new List <CSBaseExpression> (); var preMarshalCode = new List <CSLine> (); var postMarshalCode = new List <CSLine> (); CSBaseExpression valueExpr = null; bool marshalingThrows = false; if (isSetter) { var valueID = delegateParams [1].Name; valueExpr = valueID; var swiftNewValue = funcDecl.ParameterLists [1] [0]; bool newValueIsGeneric = funcDecl.IsTypeSpecGeneric(funcDecl.PropertyType); entity = !newValueIsGeneric?typeMapper.GetEntityForTypeSpec(swiftNewValue.TypeSpec) : null; entityType = !newValueIsGeneric?typeMapper.GetEntityTypeForTypeSpec(swiftNewValue.TypeSpec) : EntityType.None; var isUnusualNewValue = IsUnusualParameter(entity, delegateParams [1]); if (entityType == EntityType.Class || entity.IsObjCProtocol) { var csParmType = new CSSimpleType(entity.SharpNamespace + "." + entity.SharpTypeName); if (csParmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 26, "Inconceivable! The class type for a subscript was NOT a CSSimpleType!"); } use.AddIfNotPresent(typeof(SwiftObjectRegistry)); var fullClassName = entity.Type.ToFullyQualifiedName(true); valueExpr = NewClassCompiler.SafeMarshalClassFromIntPtr(valueID, csParmType, use, fullClassName, typeMapper, entity.IsObjCProtocol); } else if (entityType == EntityType.Protocol) { var csParmType = new CSSimpleType(entity.SharpNamespace + "." + entity.SharpTypeName); if (csParmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 27, "Inconceivable! The protocol type for a subscript was NOT a CSSimpleType!"); } use.AddIfNotPresent(typeof(StructMarshal)); use.AddIfNotPresent(typeof(SwiftObjectRegistry)); valueExpr = new CSFunctionCall($"SwiftObjectRegistry.Registry.InterfaceForExistentialContainer<{csParmType.ToString ()}>", false, valueID); } else if ((entityType == EntityType.Struct || entityType == EntityType.Enum) && !isUnusualNewValue) { var csParmType = new CSSimpleType(entity.SharpNamespace + "." + entity.SharpTypeName); if (csParmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 28, $"Inconceivable! The {entityType} type for a subscript was NOT a CSSimpleType!"); } use.AddIfNotPresent(typeof(StructMarshal)); string valMarshalName = MarshalEngine.Uniqueify("val", identifiersUsed); var valMarshalId = new CSIdentifier(valMarshalName); CSLine valDecl = CSVariableDeclaration.VarLine(csParmType, valMarshalId, new CSCastExpression(csParmType, new CSFunctionCall("StructMarshal.Marshaler.ToNet", false, valueID, csParmType.Typeof()))); preMarshalCode.Add(valDecl); valueExpr = valMarshalId; } else if (entityType == EntityType.Tuple) { var csParmType = new CSSimpleType(entity.SharpNamespace + "." + entity.SharpTypeName); if (csParmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 29, "Inconceivable! The tuple type for a subscript was NOT a CSSimpleType!"); } use.AddIfNotPresent(typeof(StructMarshal)); string valMarshalName = MarshalEngine.Uniqueify("val", identifiersUsed); var valMarshalId = new CSIdentifier(valMarshalName); var valDecl = CSVariableDeclaration.VarLine(csParmType, valMarshalId, new CSCastExpression(csParmType, new CSFunctionCall("StructMarshal.Marshaler.ToNet", false, valueID, csParmType.Typeof()))); preMarshalCode.Add(valDecl); valueExpr = valMarshalId; } else if (newValueIsGeneric) { var depthIndex = funcDecl.GetGenericDepthAndIndex(swiftNewValue.TypeSpec); var genRef = new CSGenericReferenceType(depthIndex.Item1, depthIndex.Item2); if (genRef == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 30, "Inconceivable! The generic type for a parameter in a method was NOT a CSGenericReferenceType!"); } use.AddIfNotPresent(typeof(StructMarshal)); string valMarshalName = MarshalEngine.Uniqueify("valTemp", identifiersUsed); var valMarshalId = new CSIdentifier(valMarshalName); var valDecl = CSVariableDeclaration.VarLine(genRef, valMarshalId, new CSCastExpression(genRef, new CSFunctionCall("StructMarshal.Marshaler.ToNet", false, valueID, genRef.Typeof()))); preMarshalCode.Add(valDecl); valueExpr = valMarshalId; } } int j = 0; int k = isSetter ? 1 : 0; for (int i = (funcDecl.HasThrows || returnIsStruct || returnIsProtocol || isSetter || returnIsGeneric) ? 2 : 1; i < delegateParams.Count; i++, j++, k++) { var swiftParm = funcDecl.ParameterLists [1] [k]; bool parmIsGeneric = funcDecl.IsTypeSpecGeneric(swiftParm); entity = !parmIsGeneric?typeMapper.GetEntityForTypeSpec(swiftParm.TypeSpec) : null; entityType = !parmIsGeneric?typeMapper.GetEntityTypeForTypeSpec(swiftParm.TypeSpec) : EntityType.None; var isUnusualParameter = IsUnusualParameter(entity, delegateParams [i]); var csParm = methodParams [j]; if (entityType == EntityType.Class || (entity != null && entity.IsObjCProtocol)) { var csParmType = csParm.CSType as CSSimpleType; if (csParmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 31, "Inconceivable! The class type for a method was NOT a CSSimpleType!"); } use.AddIfNotPresent(typeof(SwiftObjectRegistry)); var fullClassName = entity.Type.ToFullyQualifiedName(true); var retrievecall = NewClassCompiler.SafeMarshalClassFromIntPtr(delegateParams [0].Name, csParmType, use, fullClassName, typeMapper, entity.IsObjCProtocol); if (csParm.ParameterKind == CSParameterKind.Out || csParm.ParameterKind == CSParameterKind.Ref) { string id = MarshalEngine.Uniqueify(delegateParams [i].Name.Name, identifiersUsed); identifiersUsed.Add(id); preMarshalCode.Add(CSFieldDeclaration.FieldLine(csParmType, id, retrievecall)); callParams.Add(new CSIdentifier(String.Format("{0} {1}", csParm.ParameterKind == CSParameterKind.Out ? "out" : "ref", id))); postMarshalCode.Add(CSAssignment.Assign(delegateParams [i].Name, NewClassCompiler.SafeBackingFieldAccessor(new CSIdentifier(id), use, entity.Type.ToFullyQualifiedName(true), typeMapper))); } else { callParams.Add(retrievecall); } } else if (entityType == EntityType.Protocol) { var thePtr = new CSIdentifier(MarshalEngine.Uniqueify("p", identifiersUsed)); var csParmType = csParm.CSType as CSSimpleType; if (csParmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 32, "Inconceivable! The protocol type for a method was NOT a CSSimpleType!"); } use.AddIfNotPresent(typeof(SwiftObjectRegistry)); string csParmProxyType = NewClassCompiler.CSProxyNameForProtocol(entity.Type.ToFullyQualifiedName(true), typeMapper); if (csParmProxyType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 33, $"Unable to find C# interface type for protocol {entity.Type.ToFullyQualifiedName ()}"); } var retrievecall = new CSFunctionCall($"SwiftObjectRegistry.Registry.InterfaceForExistentialContainer<{csParmType.Name}>", false, delegateParams [i].Name); if (csParm.ParameterKind == CSParameterKind.Out || csParm.ParameterKind == CSParameterKind.Ref) { CSIdentifier id = new CSIdentifier(MarshalEngine.Uniqueify(delegateParams [i].Name.Name, identifiersUsed)); identifiersUsed.Add(id.Name); preMarshalCode.Add(CSFieldDeclaration.FieldLine(csParmType, id.Name, retrievecall)); callParams.Add(new CSIdentifier(String.Format("{0} {1}", csParm.ParameterKind == CSParameterKind.Out ? "out" : "ref", id))); postMarshalCode.Add(CSAssignment.Assign(delegateParams [i].Name, new CSFunctionCall("SwiftExistentialContainer1", true, new CSFunctionCall("SwiftObjectRegistry.Registry.ExistentialContainerForProtocol", false, id, csParmType.Typeof())))); } else { callParams.Add(retrievecall); } } else if ((entityType == EntityType.Struct || entityType == EntityType.Enum) && !isUnusualParameter) { var csParmType = csParm.CSType as CSSimpleType; if (csParmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 34, $"Inconceivable! The {entityType} type for a method was NOT a CSSimpleType!"); } use.AddIfNotPresent(typeof(StructMarshal)); use.AddIfNotPresent(typeof(StructMarshal)); string valMarshalName = MarshalEngine.Uniqueify(delegateParams [i].Name + "Temp", identifiersUsed); var valMarshalId = new CSIdentifier(valMarshalName); var valDecl = CSVariableDeclaration.VarLine(csParmType, valMarshalId, new CSCastExpression(csParmType, new CSFunctionCall("StructMarshal.Marshaler.ToNet", false, delegateParams [i].Name, csParmType.Typeof()))); preMarshalCode.Add(valDecl); callParams.Add(valMarshalId); } else if (entityType == EntityType.Tuple) { var csParmType = csParm.CSType as CSSimpleType; if (csParmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 35, "Inconceivable! The tuple type for a parameter in a method was NOT a CSSimpleType!"); } use.AddIfNotPresent(typeof(StructMarshal)); string valMarshalName = MarshalEngine.Uniqueify(delegateParams [i].Name + "Temp", identifiersUsed); var valMarshalId = new CSIdentifier(valMarshalName); var valDecl = CSVariableDeclaration.VarLine(csParmType, valMarshalId, new CSCastExpression(csParmType, new CSFunctionCall("StructMarshal.Marshaler.ToNet", false, delegateParams [i].Name, csParmType.Typeof()))); preMarshalCode.Add(valDecl); callParams.Add(valMarshalId); } else if (entityType == EntityType.Closure) { // parm is a SwiftClosureRepresentation // (FuncType)StructMarshal.Marshaler.MakeDelegateFromBlindClosure (arg, argTypes, returnType); var argTypesId = new CSIdentifier(MarshalEngine.Uniqueify("argTypes" + delegateParams [i], identifiersUsed)); identifiersUsed.Add(argTypesId.Name); var parmType = csParm.CSType as CSSimpleType; if (parmType == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 44, "Inconceivable! The type for a closure should be a CSSimpleType"); } var hasReturn = parmType.GenericTypeName == "Func"; var returnType = hasReturn ? (CSBaseExpression)parmType.GenericTypes [parmType.GenericTypes.Length - 1].Typeof() : CSConstant.Null; var argTypesLength = hasReturn ? parmType.GenericTypes.Length - 1 : parmType.GenericTypes.Length; var argTypes = new CSBaseExpression [argTypesLength]; for (int idx = 0; idx < argTypesLength; idx++) { argTypes [idx] = parmType.GenericTypes [idx].Typeof(); } var typeArr = new CSArray1DInitialized(CSSimpleType.Type, argTypes); var closureExpr = new CSFunctionCall("StructMarshal.Marshaler.MakeDelegateFromBlindClosure", false, delegateParams [i].Name, typeArr, returnType); var castTo = new CSCastExpression(csParm.CSType, closureExpr); callParams.Add(castTo); } else if (entityType == EntityType.ProtocolList) { preMarshalCode.Add(CSFunctionCall.FunctionCallLine("throw new NotImplementedException", false, CSConstant.Val($"Argument {csParm.Name} is a protocol list type and can't be marshaled from a virtual method."))); callParams.Add(CSConstant.Null); marshalingThrows = true; } else if (parmIsGeneric) { // parm is an IntPtr to some T // to get T, we ask funcDecl for the depthIndex of T // T someVal = (T)StructMarshal.Marshaler.ToNet(parm, typeof(T)); // someVal gets passed in var genRef = csParm.CSType as CSGenericReferenceType; if (genRef == null) { throw ErrorHelper.CreateError(ReflectorError.kTypeMapBase + 36, "Inconceivable! The generic type for a parameter in a method was NOT a CSGenericReferenceType!"); } use.AddIfNotPresent(typeof(StructMarshal)); string valMarshalName = MarshalEngine.Uniqueify(delegateParams [i].Name + "Temp", identifiersUsed); var valMarshalId = new CSIdentifier(valMarshalName); var valDecl = CSVariableDeclaration.VarLine(genRef, valMarshalId, new CSCastExpression(genRef, new CSFunctionCall("StructMarshal.Marshaler.ToNet", false, delegateParams [i].Name, genRef.Typeof()))); preMarshalCode.Add(valDecl); callParams.Add(valMarshalId); } else { if (csParm.ParameterKind == CSParameterKind.Out || csParm.ParameterKind == CSParameterKind.Ref) { callParams.Add(new CSIdentifier(String.Format("{0} {1}", csParm.ParameterKind == CSParameterKind.Out ? "out" : "ref", delegateParams [i].Name.Name))); } else { callParams.Add(delegateParams [i].Name); } } } var body = new CSCodeBlock(); if (isObjC) { use.AddIfNotPresent("ObjCRuntime"); } else { use.AddIfNotPresent(typeof(SwiftObjectRegistry)); } CSBaseExpression invoker = null; if (isIndexer) { if (thisIsInterface) { invoker = new CSIndexExpression( $"SwiftObjectRegistry.Registry.InterfaceForExistentialContainer<{thisType.ToString ()}> (self)", false, callParams.ToArray()); } else { var registryCall = isObjC ? $"Runtime.GetNSObject<{thisType.ToString ()}> (self)" : $"SwiftObjectRegistry.Registry.CSObjectForSwiftObject <{thisType.ToString ()}> (self)"; invoker = new CSIndexExpression(registryCall, false, callParams.ToArray()); } } else { if (thisIsInterface) { invoker = new CSFunctionCall( $"SwiftObjectRegistry.Registry.InterfaceForExistentialContainer<{thisType.ToString ()}> (self).{methodName}", false, callParams.ToArray()); } else { var registryCall = isObjC ? $"Runtime.GetNSObject<{thisType.ToString ()}>(self).{methodName}" : $"SwiftObjectRegistry.Registry.CSObjectForSwiftObject <{thisType.ToString ()}> (self).{methodName}"; invoker = new CSFunctionCall(registryCall, false, callParams.ToArray()); } } var tryBlock = funcDecl.HasThrows ? new CSCodeBlock() : null; var catchBlock = funcDecl.HasThrows ? new CSCodeBlock() : null; var altBody = tryBlock ?? body; string catchName = MarshalEngine.Uniqueify("e", identifiersUsed); var catchID = new CSIdentifier(catchName); altBody.AddRange(preMarshalCode); if (marshalingThrows) { return(altBody); } if (funcDecl.HasThrows || needsReturn) // function that returns or getter { if (funcDecl.HasThrows) { use.AddIfNotPresent(typeof(SwiftError)); use.AddIfNotPresent(typeof(Tuple)); use.AddIfNotPresent(typeof(StructMarshal)); CSType returnTuple = null; if (needsReturn) { returnTuple = new CSSimpleType("Tuple", false, methodType, new CSSimpleType(typeof(SwiftError)), CSSimpleType.Bool); } else { returnTuple = new CSSimpleType("Tuple", false, new CSSimpleType(typeof(SwiftError)), CSSimpleType.Bool); } if (needsReturn) { string retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); var retvalId = new CSIdentifier(retvalName); altBody.Add(CSFieldDeclaration.VarLine(methodType, retvalId, invoker)); postMarshalCode.Add(CSFunctionCall.FunctionCallLine("StructMarshal.Marshaler.ToSwift", false, methodType.Typeof(), retvalId, delegateParams [0].Name)); altBody.Add(CSFunctionCall.FunctionCallLine("StructMarshal.Marshaler.SetErrorNotThrown", false, delegateParams [0].Name, returnTuple.Typeof())); } else { if (isSetter) { altBody.Add(CSAssignment.Assign(invoker, CSAssignmentOperator.Assign, valueExpr)); } else { altBody.Add(new CSLine(invoker)); } altBody.Add(CSFunctionCall.FunctionCallLine("StructMarshal.Marshaler.SetErrorNotThrown", false, delegateParams [0].Name, returnTuple.Typeof())); } string swiftError = MarshalEngine.Uniqueify("err", identifiersUsed); var swiftErrorIdentifier = new CSIdentifier(swiftError); catchBlock.Add(CSFieldDeclaration.VarLine(new CSSimpleType(typeof(SwiftError)), swiftErrorIdentifier, new CSFunctionCall("SwiftError.FromException", false, catchID))); catchBlock.Add(CSFunctionCall.FunctionCallLine("StructMarshal.Marshaler.SetErrorThrown", false, delegateParams [0].Name, swiftErrorIdentifier, returnTuple.Typeof())); } else { if (returnIsClass) { string retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); CSIdentifier retvalId = new CSIdentifier(retvalName); altBody.Add(CSFieldDeclaration.VarLine(methodType, retvalId, invoker)); postMarshalCode.Add(CSReturn.ReturnLine( NewClassCompiler.SafeBackingFieldAccessor(retvalId, use, returnEntity.Type.ToFullyQualifiedName(), typeMapper))); } else if (returnIsProtocol) { string retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); identifiersUsed.Add(retvalName); var retvalId = new CSIdentifier(retvalName); altBody.Add(CSFieldDeclaration.VarLine(methodType, retvalId, invoker)); var returnContainer = MarshalEngine.Uniqueify("returnContainer", identifiersUsed); identifiersUsed.Add(returnContainer); var returnContainerId = new CSIdentifier(returnContainer); var protoGetter = new CSFunctionCall($"SwiftObjectRegistry.Registry.ExistentialContainerForProtocols", false, retvalId, methodType.Typeof()); var protoDecl = CSVariableDeclaration.VarLine(CSSimpleType.Var, returnContainerId, protoGetter); var marshalBack = CSFunctionCall.FunctionCallLine($"{returnContainer}.CopyTo", delegateParams [0].Name); postMarshalCode.Add(protoDecl); postMarshalCode.Add(marshalBack); } else if (returnIsStruct) { // non-blitable means that the parameter is an IntPtr and we can call the // marshaler to copy into it use.AddIfNotPresent(typeof(StructMarshal)); var marshalCall = CSFunctionCall.FunctionCallLine("StructMarshal.Marshaler.ToSwift", false, invoker, delegateParams [0].Name); altBody.Add(marshalCall); } else if (returnIsTuple) { // non-blitable means that the parameter is an IntPtr and we can call the // marshaler to copy into it use.AddIfNotPresent(typeof(StructMarshal)); var marshalCall = CSFunctionCall.FunctionCallLine("StructMarshal.Marshaler.ToSwift", false, invoker, delegateParams [0].Name); altBody.Add(marshalCall); } else if (returnIsGeneric) { // T retval = invoker(); // if (retval is ISwiftObject) { // Marshal.WriteIntPtr(delegateParams [0].Name, ((ISwiftObject)retval).SwiftObject); // } // else { // StructMarshal.Marshaler.ToSwift(typeof(T), retval, delegateParams[0].Name); // } string retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); var retvalId = new CSIdentifier(retvalName); altBody.Add(CSFieldDeclaration.VarLine(methodType, retvalId, invoker)); var ifClause = new CSCodeBlock(); ifClause.Add(CSFunctionCall.FunctionCallLine("Marshal.WriteIntPtr", false, delegateParams [0].Name, new CSParenthesisExpression(new CSCastExpression("ISwiftObject", retvalId)).Dot(NewClassCompiler.kSwiftObjectGetter))); var elseClause = new CSCodeBlock(); elseClause.Add(CSFunctionCall.FunctionCallLine("StructMarshal.Marshaler.ToSwift", false, methodType.Typeof(), retvalId, delegateParams [0].Name)); CSBaseExpression ifExpr = new CSSimpleType("ISwiftObject").Typeof().Dot(new CSFunctionCall("IsAssignableFrom", false, methodType.Typeof())); var retTest = new CSIfElse(ifExpr, ifClause, elseClause); altBody.Add(retTest); } else { if (returnIsClosure) { invoker = MarshalEngine.BuildBlindClosureCall(invoker, methodType as CSSimpleType, use); } if (postMarshalCode.Count > 0) { string retvalName = MarshalEngine.Uniqueify("retval", identifiersUsed); CSIdentifier retvalId = new CSIdentifier(retvalName); altBody.Add(CSFieldDeclaration.VarLine(methodType, retvalId, invoker)); postMarshalCode.Add(CSReturn.ReturnLine(retvalId)); } else { altBody.Add(CSReturn.ReturnLine(invoker)); } } } } else // no return or setter { if (isSetter) { altBody.Add(CSAssignment.Assign(invoker, CSAssignmentOperator.Assign, valueExpr)); } else { altBody.Add(new CSLine(invoker)); } } altBody.AddRange(postMarshalCode); if (funcDecl.HasThrows) { body.Add(new CSTryCatch(tryBlock, new CSCatch(typeof(Exception), catchName, catchBlock))); } return(body); }
public static CSNamespace CreateManagedConsoleRedirect() { // Same as GetManagedConsoleRedirectCode, just different format. var cs = new CSNamespace(); var console = new CSClass(CSVisibility.Public, "Console", isStatic: true); console.Fields.Add(CSFieldDeclaration.FieldLine(CSSimpleType.String, new CSIdentifier("filename"), isStatic: true)); console.Properties.Add( new CSProperty( CSSimpleType.String, CSMethodKind.Static, new CSIdentifier("Filename"), CSVisibility.None, CSCodeBlock.Create( new CSIfElse( new CSBinaryExpression( CSBinaryOperator.Equal, new CSIdentifier("filename"), new CSIdentifier("null") ), CSCodeBlock.Create( CSAssignment.Assign( new CSIdentifier("filename"), new CSBinaryExpression( CSBinaryOperator.NullCoalesce, CSFunctionCall.Function( "Environment.GetEnvironmentVariable", CSConstant.Val("LEAKTEST_STDOUT_PATH") ), new CSIdentifier("string.Empty") ) ) ) ), CSReturn.ReturnLine(new CSIdentifier("filename")) ), CSVisibility.None, null ) ); console.Methods.Add( new CSMethod( CSVisibility.Public, CSMethodKind.Static, CSSimpleType.Void, new CSIdentifier("write"), new CSParameterList( new CSParameter(CSSimpleType.String, new CSIdentifier("value")) ), CSCodeBlock.Create( new CSIfElse( new CSIdentifier("string.IsNullOrEmpty (Filename)"), CSCodeBlock.Create(CSFunctionCall.FunctionCallLine("global::System.Console.Write", new CSIdentifier("value"))), CSCodeBlock.Create(CSFunctionCall.FunctionCallLine("System.IO.File.AppendAllText", new CSIdentifier("Filename"), new CSIdentifier("value"))) ) ) ) ); console.Methods.Add( new CSMethod( CSVisibility.Public, CSMethodKind.Static, CSSimpleType.Void, new CSIdentifier("Write"), new CSParameterList( new CSParameter(CSSimpleType.Object, new CSIdentifier("value")) ), CSCodeBlock.Create( CSFunctionCall.FunctionCallLine( "write", false, new CSIdentifier("value?.ToString ()") ) ) ) ); console.Methods.Add( new CSMethod( CSVisibility.Public, CSMethodKind.Static, CSSimpleType.Void, new CSIdentifier("Write"), new CSParameterList( new CSParameter(CSSimpleType.String, new CSIdentifier("value")), new CSParameter(CSSimpleType.CreateArray("object"), new CSIdentifier("args"), CSParameterKind.Params) ), CSCodeBlock.Create( CSFunctionCall.FunctionCallLine( "write", false, new CSIdentifier("value == null ? string.Empty : string.Format (value, args)") ) ) ) ); console.Methods.Add( new CSMethod( CSVisibility.Public, CSMethodKind.Static, CSSimpleType.Void, new CSIdentifier("WriteLine"), new CSParameterList( new CSParameter(CSSimpleType.Object, new CSIdentifier("value")) ), CSCodeBlock.Create( CSFunctionCall.FunctionCallLine( "write", false, new CSIdentifier("value?.ToString () + Environment.NewLine") ) ) ) ); console.Methods.Add( new CSMethod( CSVisibility.Public, CSMethodKind.Static, CSSimpleType.Void, new CSIdentifier("WriteLine"), new CSParameterList( new CSParameter(CSSimpleType.String, new CSIdentifier("value")), new CSParameter(CSSimpleType.CreateArray("object"), new CSIdentifier("args"), CSParameterKind.Params) ), CSCodeBlock.Create( CSFunctionCall.FunctionCallLine( "write", false, new CSIdentifier("(value == null ? string.Empty : string.Format (value, args)) + Environment.NewLine") ) ) ) ); cs.Block.Add(console); return(cs); }
public void ClassEquals() { // Note for future Steve // If an argument is a protocol with associated types, the calling conventions are different. // Typically, if a function accepts a protocol type as its argument it gets passed in as an existential // container. // It appears that if a function is generic with a protocol constraint then the argument gets // passed in as a pointer to the type then with the attendant metadata and protocol witness table // As a result, this code crashes since we're passing in the wrong type as far as I can tell. // This clearly needs more investigation // note to current or future Steve: // The calling conventions for this are: // rdi - pointer to value containing a // rsi - pointer to value containing b // rdx - metadata for type T // rcx - protocol witness table for T // // in pinvoke terms, this is // extern static void areEqualClass(IntPtr a, IntPtr b, SwiftMetatype mt, IntPtr protowitness); var swiftCode = $"public func areEqualClass<T:Equatable>(a: T, b: T) -> Bool {{\n" + " return a == b\n" + "}\n" + "public protocol XXEquals {\n" + " func Equals() -> Bool\n" + "}\n" ; var eqClass = new CSClass(CSVisibility.Public, "EqClass"); var field = CSVariableDeclaration.VarLine(CSSimpleType.Int, "X"); eqClass.Fields.Add(field); var ctorParms = new CSParameterList(); ctorParms.Add(new CSParameter(CSSimpleType.Int, new CSIdentifier("x"))); var assignLine = CSAssignment.Assign("X", new CSIdentifier("x")); var ctor = new CSMethod(CSVisibility.Public, CSMethodKind.None, null, new CSIdentifier("EqClass"), ctorParms, CSCodeBlock.Create(assignLine)); eqClass.Constructors.Add(ctor); eqClass.Inheritance.Add(typeof(ISwiftEquatable)); var eqParms = new CSParameterList(); eqParms.Add(new CSParameter(new CSSimpleType("ISwiftEquatable"), new CSIdentifier("other"))); var castLine = CSVariableDeclaration.VarLine(new CSSimpleType("EqClass"), "otherEqClass", new CSBinaryExpression(CSBinaryOperator.As, new CSIdentifier("other"), new CSIdentifier("EqClass"))); var nonNull = new CSBinaryExpression(CSBinaryOperator.NotEqual, new CSIdentifier("otherEqClass"), CSConstant.Null); var valsEq = new CSBinaryExpression(CSBinaryOperator.Equal, new CSIdentifier("otherEqClass.X"), new CSIdentifier("X")); var returnLine = CSReturn.ReturnLine(new CSBinaryExpression(CSBinaryOperator.And, nonNull, valsEq)); var opEquals = new CSMethod(CSVisibility.Public, CSMethodKind.None, CSSimpleType.Bool, new CSIdentifier("OpEquals"), eqParms, CSCodeBlock.Create(castLine, returnLine)); eqClass.Methods.Add(opEquals); var newClass = new CSFunctionCall("EqClass", true, CSConstant.Val(5)); var isEqual = new CSFunctionCall($"TopLevelEntities.AreEqualClass", false, newClass, newClass); var printer = CSFunctionCall.ConsoleWriteLine(isEqual); var callingCode = CSCodeBlock.Create(printer); TestRunning.TestAndExecute(swiftCode, callingCode, "True\n", otherClass: eqClass, platform: PlatformName.macOS); }
public CSProperty CompileProperty(CSUsingPackages packs, string propertyName, FunctionDeclaration getter, FunctionDeclaration setter, CSMethodKind methodKind = CSMethodKind.None) { var swiftPropertyType = GetPropertyType(getter, setter); NetTypeBundle propertyType = null; if (TypeMapper.IsCompoundProtocolListType(swiftPropertyType)) { propertyType = new NetTypeBundle("System", "object", false, false, EntityType.ProtocolList); } else { propertyType = typeMap.MapType(getter, swiftPropertyType, false, true); } propertyName = propertyName ?? typeMap.SanitizeIdentifier(getter != null ? getter.PropertyName : setter.PropertyName); bool isSubscript = getter != null ? getter.IsSubscript : setter.IsSubscript; if (!getter.IsTypeSpecGeneric(swiftPropertyType)) { AddUsingBlock(packs, propertyType); } var uselessLine = new ICodeElement [] { CSReturn.ReturnLine(new CSIdentifier("useless")) }; CSCodeBlock getterBlock = null; if (getter != null) { getterBlock = new CSCodeBlock(uselessLine); } CSCodeBlock setterBlock = null; if (setter != null) { setterBlock = new CSCodeBlock(uselessLine); } CSProperty theProp = null; if (isSubscript) { List <ParameterItem> swiftParms = null; if (getter != null) { swiftParms = getter.ParameterLists [1]; } else { swiftParms = setter.ParameterLists [1].Skip(1).ToList(); } var args = typeMap.MapParameterList(getter, swiftParms, false, false, null, null); args.ForEach(a => AddUsingBlock(packs, a.Type)); var csParams = new CSParameterList( args.Select(a => new CSParameter(a.Type.ToCSType(packs), new CSIdentifier(a.Name), a.Type.IsReference ? CSParameterKind.Ref : CSParameterKind.None, null))); theProp = new CSProperty(propertyType.ToCSType(packs), methodKind, CSVisibility.Public, getterBlock, CSVisibility.Public, setterBlock, csParams); } else { theProp = new CSProperty(propertyType.ToCSType(packs), methodKind, new CSIdentifier(propertyName), CSVisibility.Public, getterBlock, CSVisibility.Public, setterBlock); } if (getterBlock != null) { getterBlock.Clear(); } if (setterBlock != null) { setterBlock.Clear(); } return(theProp); }