string CompileWithInvokingCode(CSFile cs, CSLine invoker, string nameSpace)
{
CSNamespace ns = new CSNamespace(nameSpace);
CSCodeBlock mainBody = CSCodeBlock.Create(invoker);
CSMethod main = new CSMethod(CSVisibility.Public, CSMethodKind.Static, CSSimpleType.Void,
new CSIdentifier("Main"), new CSParameterList(new CSParameter(new CSSimpleType("string", true), "args")),
mainBody);
CSClass cl = new CSClass(CSVisibility.Public, "NameNotImportant", new CSMethod [] { main });
ns.Block.Add(cl);
cs.Namespaces.Add(ns);
using (DisposableTempFile csOut = new DisposableTempFile(null, null, "cs", true)) {
CodeWriter.WriteToFile(csOut.Filename, cs);
using (Stream csExeStm = Compiler.CompileUsing(null, XCodeCompiler.CSharpExe, csOut.Filename,
$"-lib:{kSwiftRuntimeMacOutputDirectory} -r:{kSwiftRuntimeLibraryMac}")) {
using (DisposableTempFile csExe = new DisposableTempFile(null, null, "exe", true)) {
csExeStm.CopyTo(csExe.Stream);
csExe.Stream.Close();
string output = Compiler.RunWithMono(csExe.Filename);
return(output);
}
}
}
}
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);
}
void WrapOptionalArg(string type1, string cstype1, string val1, string expected, bool isStatic = true, string distinguisher = "")
{
var typeString = type1 + distinguisher;
string finalDecl = (isStatic ? "final" : "");
string statDecl = (isStatic ? "static" : "");
string swiftCode = TestRunningCodeGenerator.kSwiftFileWriter +
$"public {finalDecl} class MontyWOA{typeString} {{ public init() {{ }}\n public {statDecl} func printOpt(a:{type1}?)\n {{\n var s = \"\"\nif a != nil {{\n print(\"Optional(\\(a!))\", to:&s)\n }}\n else {{ print(\"nil\", to:&s)\n }}\nwriteToFile(s, \"WrapOptionalArg{typeString}\")\n }}\n}}\n";
CSBaseExpression optValue = null;
if (val1 != null)
{
optValue = new CSFunctionCall(String.Format("SwiftOptional<{0}>", cstype1), true, new CSIdentifier(val1));
}
else
{
optValue = new CSFunctionCall(String.Format("SwiftOptional<{0}>.None", cstype1), false);
}
CSLine csopt = CSVariableDeclaration.VarLine(new CSSimpleType("SwiftOptional", false, new
CSSimpleType(cstype1)), "opt", optValue);
CSLine printer = CSFunctionCall.FunctionCallLine((isStatic ? $"MontyWOA{typeString}.PrintOpt" : $"new MontyWOA{typeString}().PrintOpt"), false, new CSIdentifier("opt"));
CSCodeBlock callingCode = CSCodeBlock.Create(csopt, printer);
TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapOptionalArg{typeString}");
}
protected override string GenerateVariableGetFunctionReturnContainerType(string type)
{
return(CSLine.Single("EnumerableLookupSet<?LABEL_TYPE, ?TYPE>",
"LABEL_TYPE", GetLabelTypeConcept().GetStoreTypeName(),
"TYPE", type
));
}
public override string GetStringToTypeExpression(string string_expression)
{
return(CSLine.Single("?STRING_EXPRESSION.Parse?TYPE()",
"STRING_EXPRESSION", string_expression,
"TYPE", GetTypeName().StyleAsFunctionName()
));
}
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 TestCharacterConstructors()
{
var swiftCode = @"public func Echo (c: Character) -> Character { return c; }";
var callingCode = new CodeElementCollection <ICodeElement> ();
StringBuilder expected = new StringBuilder();
foreach (string c in TestCases)
{
CSIdentifier testIdentifier = (CSIdentifier)$@"""{c}""";
var ctorCall = CSFunctionCall.Ctor("SwiftCharacter", testIdentifier);
var fromCall = CSFunctionCall.Function("SwiftCharacter.FromCharacter", testIdentifier);
var implicitCall = new CSCastExpression((CSSimpleType)"SwiftCharacter", testIdentifier);
foreach (var call in new CSBaseExpression [] { ctorCall, fromCall, implicitCall })
{
CSLine print = CSFunctionCall.FunctionLine("Console.Write", CSFunctionCall.Function("TopLevelEntities.Echo", call));
callingCode.Add(print);
expected.Append(c);
}
}
TestRunning.TestAndExecute(swiftCode, callingCode, expected.ToString());
}
public string GetContextToTypeExpression(string context_expression)
{
return(CSLine.Single("?TYPE.DOMify(?CONTEXT_EXPRESSION)",
"TYPE", GetTypeName(),
"CONTEXT_EXPRESSION", context_expression
));
}
public void TLDictionaryAddGet(string sKeyType, string sValType,
string csKeyType, string csValType, string csKey, string csValue, string output)
{
string swiftCode =
$"public func makeDictTLDAG{sKeyType}{sValType}() -> [{sKeyType}:{sValType}]\n {{\n return [{sKeyType}:{sValType}]() \n}}\n";
CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> ();
CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType("SwiftDictionary", false,
new CSSimpleType(csKeyType),
new CSSimpleType(csValType)),
new CSIdentifier("dict"),
new CSFunctionCall($"TopLevelEntities.MakeDictTLDAG{sKeyType}{sValType}", false));
CSLine call = CSFunctionCall.FunctionCallLine("Console.Write", false, new CSIdentifier("dict.Count"));
CSLine addcall = CSFunctionCall.FunctionCallLine("dict.Add", false, new CSIdentifier(csKey),
new CSIdentifier(csValue));
CSLine writeCall = CSFunctionCall.FunctionCallLine("Console.Write", false, CSConstant.Val(' '));
CSLine getLine = CSVariableDeclaration.VarLine(new CSSimpleType(csValType), "val",
new CSArray1D("dict", new CSIdentifier(csKey)));
CSLine valueWrite = CSFunctionCall.FunctionCallLine("Console.Write", false, new CSIdentifier("val"));
callingCode.Add(decl);
callingCode.Add(call);
callingCode.Add(addcall);
callingCode.Add(writeCall);
callingCode.Add(call);
callingCode.Add(writeCall);
callingCode.Add(getLine);
callingCode.Add(valueWrite);
TestRunning.TestAndExecute(swiftCode, callingCode, output, testName: $"TLDictionaryAddGet{sKeyType}{sValType}");
}
void TLArrayMethodRemove(string swiftType, string csType, string csValue, string csNewValue, string output)
{
string swiftCode =
$"public class FooTLAMR{swiftType} {{\n" +
$"public init() {{ }}\n" +
$"public func makeArray(a:{swiftType}) -> [{swiftType}]\n {{\n return [{swiftType}](repeating:a, count:2) \n}}\n" +
$"}}";
CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> ();
CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType("SwiftArray", false, new CSSimpleType(csType)),
new CSIdentifier("arr"),
new CSFunctionCall($"new FooTLAMR{swiftType}().MakeArray", false, new CSIdentifier(csValue)));
CSLine addLine = CSFunctionCall.FunctionCallLine("arr.Insert", false, CSConstant.Val(1), new CSIdentifier(csNewValue));
CSLine remLine = CSFunctionCall.FunctionCallLine("arr.RemoveAt", false, CSConstant.Val(1));
CSLine call = CSFunctionCall.FunctionCallLine("Console.Write", false, new CSIdentifier("arr.Count"));
CSForEach feach = new CSForEach(new CSSimpleType(csType), "x", new CSIdentifier("arr"), null);
feach.Body.Add(CSFunctionCall.FunctionCallLine("Console.Write", false, CSConstant.Val(" {0}"), feach.Ident));
callingCode.Add(decl);
callingCode.Add(addLine);
callingCode.Add(remLine);
callingCode.Add(call);
callingCode.Add(feach);
TestRunning.TestAndExecute(swiftCode, callingCode, output, testName: $"TLArrayMethodRemove{swiftType}");
}
void WrapMultiTuple(string type, int count, string appendage, string expected, int nothing, params string [] values)
{
StringBuilder sbargs = new StringBuilder();
StringBuilder sbtype = new StringBuilder();
StringBuilder sbret = new StringBuilder();
for (int i = 0; i < count; i++)
{
if (i > 0)
{
sbargs.Append(", ");
sbtype.Append(", ");
sbret.Append(", ");
}
sbargs.Append(String.Format("a{0}: {1}", i, type));
sbtype.Append(type);
sbret.Append(String.Format("a{0}", i));
}
string swiftCode =
$"public final class MontyWMT{appendage} {{ public init() {{ }}\n public static func tupe({sbargs.ToString ()}) -> ({sbtype.ToString ()})\n {{\n return ({sbret.ToString ()});\n }}\n}}\n";
CSBaseExpression [] args = values.Select(str => (CSBaseExpression) new CSIdentifier(str)).ToArray();
CSLine cstupe = CSVariableDeclaration.VarLine(new CSSimpleType("var"), "tupe",
new CSFunctionCall($"MontyWMT{appendage}.Tupe", false, args));
CSLine printer = CSFunctionCall.ConsoleWriteLine((CSIdentifier)"tupe");
CSCodeBlock callingCode = CSCodeBlock.Create(cstupe, printer);
TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapMultiTuple{appendage}");
}
public override string GetStringToTypeExpression(string string_expression)
{
return(CSLine.Single("new ?TYPE(?STRING_EXPRESSION)",
"TYPE", GetTypeName(),
"STRING_EXPRESSION", string_expression
));
}
public DOMEVariableType_Multiple_Primitive_List(DOMEVariableTypeConcept t) : base(t)
{
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(CSLine.Single("List<?INNER_TYPE>",
"INNER_TYPE", GetTypeConcept().GetStoreTypeName()
));
});
}
public DOMEVariableType_Multiple_RuleDefinition_NoParent_List(DOMEClass p, DOMEVariableTypeConcept t) : base(p, t)
{
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(CSLine.Single("List<?INNER_TYPE>",
"INNER_TYPE", GetTypeConcept().GetStoreTypeName()
));
});
}
void WrapSingleGetSetSubscript0(string type, string returnVal, string csType, string csReplacement, string expected)
{
string swiftCode = $"public class MontyWSGSSub{type} {{ public init() {{}}\n private var _x:{type} = {returnVal}\npublic subscript(i:Int32) -> {type} {{\nget {{ return _x\n}}\nset {{ _x = newValue\n}} }} }}";
CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType($"MontyWSGSSub{type}"), "monty", new CSFunctionCall($"MontyWSGSSub{type}", true));
CSLine invoker = CSFunctionCall.ConsoleWriteLine((CSIdentifier)"monty[0]");
CSCodeBlock callingCode = CSCodeBlock.Create(decl, invoker);
TestRunning.TestAndExecute(swiftCode, callingCode, expected, $"WrapSingleGetSetSubscript0{type}");
}
public void ArcClassStruct()
{
string swiftCode =
"public final class Foo {\npublic var _nm:String\npublic init(name:String) {\n_nm = name }\n" +
"deinit {\nprint(_nm)\n}\n}\n" +
"public struct Bar {\n public var a:Foo\n public init(f:Foo) {\n a = f\n}\n }\n"
;
swiftCode += TestRunning.CreateSwiftConsoleRedirect();
using (TempDirectoryFilenameProvider provider = new TempDirectoryFilenameProvider(null, true)) {
Utils.CompileSwift(swiftCode, provider);
string libFileName = Path.Combine(provider.DirectoryPath, "libXython.dylib");
var errors = new ErrorHandling();
ModuleInventory.FromFile(libFileName, errors);
Utils.CheckErrors(errors);
Utils.CompileToCSharp(provider);
CSUsingPackages use = new CSUsingPackages("System", "System.Runtime.InteropServices", "SwiftRuntimeLibrary");
CSNamespace ns = new CSNamespace("Xython");
CSFile csfile = CSFile.Create(use, ns);
CSIdentifier inst = new CSIdentifier("inst");
CSLine newer = CSVariableDeclaration.VarLine((CSSimpleType)"Foo", inst, CSFunctionCall.Ctor("Foo",
CSFunctionCall.Function("SwiftString.FromString", CSConstant.Val("nothing"))));
CSIdentifier inst1 = new CSIdentifier("bar");
CSLine newer1 = CSVariableDeclaration.VarLine((CSSimpleType)"Bar", inst1, CSFunctionCall.Ctor("Bar", inst));
CSLine disposer = CSFunctionCall.FunctionCallLine(inst.Name + ".Dispose", false);
CSLine disposer1 = CSFunctionCall.FunctionCallLine(inst1.Name + ".Dispose", false);
CSCodeBlock mainBody = CSCodeBlock.Create(newer, newer1, disposer, disposer1);
CSMethod main = new CSMethod(CSVisibility.Public, CSMethodKind.Static, CSSimpleType.Void,
(CSIdentifier)"Main", new CSParameterList(new CSParameter(CSSimpleType.CreateArray("string"), "args")),
mainBody);
CSClass mainClass = new CSClass(CSVisibility.Public, "NameNotImportant", new CSMethod [] { main });
ns.Block.Add(mainClass);
string csOutFilename = provider.ProvideFileFor(provider.UniqueName(null, "CSWrap", "cs"));
var exeOutFilename = provider.UniquePath(null, "CSWrap", "exe");
CodeWriter.WriteToFile(csOutFilename, csfile);
Compiler.CSCompile(provider.DirectoryPath, Directory.GetFiles(provider.DirectoryPath, "*.cs"), exeOutFilename);
TestRunning.CopyTestReferencesTo(provider.DirectoryPath);
string output = Compiler.RunWithMono(exeOutFilename, provider.DirectoryPath);
Assert.AreEqual("nothing\n", output);
}
}
public DOMEVariableType_Single_RuleDefinition_AutoParent(DOMEClass p, DOMEVariableTypeConcept t) : base(p, t)
{
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(CSLine.Single("HoldingSingle<?PARENT_TYPE, ?INNER_TYPE>",
"PARENT_TYPE", GetParentType().GetTypeName(),
"INNER_TYPE", GetTypeConcept().GetStoreTypeName()
));
});
}
public void WrapSingleGetSetSubscript3()
{
string swiftCode = $"public struct FooWSGSub3 {{ public let X:Int\npublic init(i:Int) {{ X = i\n }} }}\n public class MontyWSGSub3 {{ public init() {{}}\n private var _x:FooWSGSub3 = FooWSGSub3(i:42);\npublic subscript(i:Int32) -> FooWSGSub3 {{\nget {{ return _x\n}}\nset {{ _x = newValue\n}} }} }}";
CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType("MontyWSGSub3"), "monty", new CSFunctionCall("MontyWSGSub3", true));
CSLine invoker = CSFunctionCall.ConsoleWriteLine((CSIdentifier)"monty[0].X");
CSLine setter = CSAssignment.Assign("monty[0]", new CSFunctionCall("FooWSGSub3", true, CSConstant.Val(37L)));
CSCodeBlock callingCode = CSCodeBlock.Create(decl, invoker, setter, invoker);
TestRunning.TestAndExecute(swiftCode, callingCode, "42\n37\n");
}
public DOMEVariableType_Multiple_RuleDefinition_NoParent_LabeledItemSet(DOMEClass p, DOMEVariableTypeConcept t, DOMEVariableTypeConcept l) : base(p, t)
{
label_type_concept = l;
get_type_name = new OperationCache <string>("get_type_name", delegate() {
return(CSLine.Single("LabeledItemSet<?LABEL_TYPE, ?INNER_TYPE>",
"LABEL_TYPE", GetLabelTypeConcept().GetStoreTypeName(),
"INNER_TYPE", GetTypeConcept().GetStoreTypeName()
));
});
}
static CodeElementCollection <ICodeElement> CaptureSwiftOutputPostlude(string fileName)
{
//#if _MAC_TS_TEST_
// string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), fileName);
//#else
//NSUrl[] urls = NSFileManager.DefaultManager.GetUrls(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomain.User);
//string path = Path.Combine(urls[0].Path, fileName);
//#endif
//NSUrl[] urls = NSFileManager.DefaultManager.GetUrls(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomain.User);
//string path = Path.Combine(urls[0].Path, fileName);
//if (File.Exists(path))
//{
// Console.Write(File.ReadAllText(path));
//}
CSCodeBlock block = new CSCodeBlock();
CSIdentifier pathID = new CSIdentifier("path");
block.Add(new CSIdentifier("\n#if _MAC_TS_TEST_\n"));
block.Add(CSVariableDeclaration.VarLine(CSSimpleType.String, pathID,
new CSFunctionCall("Path.Combine", false,
new CSIdentifier("Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)") +
CSConstant.Val("/Documents/"),
CSConstant.Val(fileName))));
block.Add(new CSIdentifier("\n#else\n"));
CSIdentifier urlID = new CSIdentifier("urls");
CSLine urlsLine = CSVariableDeclaration.VarLine(new CSSimpleType("NSUrl", true), urlID,
new CSFunctionCall("NSFileManager.DefaultManager.GetUrls", false,
new CSIdentifier("NSSearchPathDirectory.DocumentDirectory"),
new CSIdentifier("NSSearchPathDomain.User")));
block.Add(urlsLine);
CSLine pathLine = CSVariableDeclaration.VarLine(CSSimpleType.String, pathID,
new CSFunctionCall("Path.Combine", false,
new CSArray1D(urlID.Name, CSConstant.Val(0)).Dot(new CSIdentifier("Path")),
CSConstant.Val(fileName)));
block.Add(pathLine);
block.Add(new CSIdentifier("\n#endif\n"));
CSCodeBlock ifBlock = new CSCodeBlock();
CSLine writer = CSFunctionCall.FunctionCallLine("Console.Write", false, new CSFunctionCall("File.ReadAllText", false, pathID));
ifBlock.Add(writer);
ifBlock.Add(CSFunctionCall.FunctionCallLine("File.Delete", false, pathID));
CSIfElse iftest = new CSIfElse(new CSFunctionCall("File.Exists", false, pathID), ifBlock);
block.Add(iftest);
return(block);
}
public void WrapImplicitlyUnwrappedOptional(string swiftType, string swiftVal, string csType, string expected)
{
string swiftCode = $"public func returnBang{swiftType}()->{swiftType}! {{\n" +
$" return {swiftVal}\n" +
"}";
CSLine csopt = CSVariableDeclaration.VarLine(new CSSimpleType($"SwiftOptional<{csType}>"), "foo",
new CSFunctionCall($"TopLevelEntities.ReturnBang{swiftType}", false));
CSLine printer = CSFunctionCall.ConsoleWriteLine((CSIdentifier)"foo.Value");
CSCodeBlock callingCode = CSCodeBlock.Create(csopt, printer);
TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"WrapImplicitlyUnwrappedOptional{swiftType}");
}
private void BuildRenderCSLine(RenderTreeBuilder builder, CSLine csLine)
{
builder.OpenElement(Next(), "span");
builder.AddAttribute(Next(), "class", _themeRazorKeywordClass);
string lineType = GetLineType(csLine.LineType);
builder.AddContent(Next(), "@" + lineType);
builder.CloseElement();
builder.OpenElement(Next(), "span");
//builder.AddAttribute(Next(), "class", _textClass);
builder.AddContent(Next(), csLine.Line);
builder.CloseElement();
}
void TupleProp(string type1, string type2, string cstype1, string cstype2, string val1, string val2, string expected)
{
string appendage = type1 + type2.Replace('(', '_').Replace(')', '_').Replace(',', '_').Replace(' ', '_');
string swiftCode = $"public final class MontyTupleProp{appendage} {{ public init() {{ }}\n public var prop:({type1}, {type2}) {{\n return ({val1}, {val2});\n }}\n}}\n";
CSLine cstupe = CSVariableDeclaration.VarLine(new CSSimpleType("Tuple", false, new CSSimpleType(cstype1),
new CSSimpleType(cstype2)),
"tupe", new CSFunctionCall($"MontyTupleProp{appendage}", true).Dot(new CSIdentifier("Prop")));
CSLine printer = CSFunctionCall.ConsoleWriteLine((CSIdentifier)"tupe");
CSCodeBlock callingCode = CSCodeBlock.Create(cstupe, printer);
TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"TupleProp{appendage}");
}
public void TopLevelFunctionHomonym()
{
var swiftCode =
"public func same(a:Int) -> Int { return a }\n" +
"public func same(b:Int) -> Int { return b }\n" +
"public func same(b:Int) -> Bool { return true }\n";
var call = new CSFunctionCall("TopLevelEntities.Same_a_nint", false, CSConstant.Val(14));
var call1 = new CSFunctionCall("TopLevelEntities.Same_b_bool", false, CSConstant.Val(14));
CSLine printer = CSFunctionCall.ConsoleWriteLine(call);
CSLine printer1 = CSFunctionCall.ConsoleWriteLine(call1);
CSCodeBlock callingCode = CSCodeBlock.Create(printer, printer1);
TestRunning.TestAndExecute(swiftCode, callingCode, "14\nTrue\n");
}
void Wrap2Tuple(string type1, string type2, string cstype1, string cstype2, string val1, string val2, string expected)
{
string typetype = type1 + type2;
string swiftCode = $"public final class MontyW2T{typetype} {{ public init() {{ }}\n public static func tupe(a:{type1}, b: {type2}) -> ({type1}, {type2})\n {{\n return (a, b);\n }}\n}}\n";
CSLine cstupe = CSVariableDeclaration.VarLine(new CSSimpleType("Tuple", false, new CSSimpleType(cstype1),
new CSSimpleType(cstype2)), "tupe", new CSFunctionCall($"MontyW2T{typetype}.Tupe", false,
new CSIdentifier(val1), new CSIdentifier(val2)));
CSLine printer = CSFunctionCall.ConsoleWriteLine((CSIdentifier)"tupe");
CSCodeBlock callingCode = CSCodeBlock.Create(cstupe, printer);
TestRunning.TestAndExecute(swiftCode, callingCode, expected, testName: $"Wrap2Tuple{typetype}");
}
void TLArraySimple(string swiftType, string csType, string output)
{
string swiftCode =
$"public func makeArrayTLAS{swiftType}() -> [{swiftType}]\n {{\n return [{swiftType}]() \n}}\n";
CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> ();
CSLine decl = CSVariableDeclaration.VarLine(new CSSimpleType("SwiftArray", false, new CSSimpleType(csType)),
new CSIdentifier("arr"),
new CSFunctionCall($"TopLevelEntities.MakeArrayTLAS{swiftType}", false));
CSLine call = CSFunctionCall.FunctionCallLine("Console.Write", false, new CSIdentifier("arr.Count"));
callingCode.Add(decl);
callingCode.Add(call);
TestRunning.TestAndExecute(swiftCode, callingCode, output, testName: $"MakeArrayTLAS{swiftType}");
}
public void TestConstructorClassHomonym()
{
var swiftCode =
"public class FooClassCtor {\n" +
" public var x:Int\n" +
" public init(a:Int) { x = a\n }\n" +
" public init(b:Int) { x = b + b\n }\n" +
"}\n";
var call = new CSFunctionCall("FooClassCtor.FooClassCtor_a", false, CSConstant.Val(14));
var call1 = new CSFunctionCall("FooClassCtor.FooClassCtor_b", false, CSConstant.Val(14));
CSLine printer = CSFunctionCall.ConsoleWriteLine(call.Dot(new CSIdentifier("X")));
CSLine printer1 = CSFunctionCall.ConsoleWriteLine(call1.Dot(new CSIdentifier("X")));
CSCodeBlock callingCode = CSCodeBlock.Create(printer, printer1);
TestRunning.TestAndExecute(swiftCode, callingCode, "14\n28\n");
}
void WrapVirtualTuple(string type1, string type2, string cstype1, string cstype2, string val1, string val2, string expected)
{
string appendage = type1 + type2;
string swiftCode = TestRunningCodeGenerator.kSwiftFileWriter +
$"public class MontyWVT{appendage} {{ public init() {{ }}\n public func tupe(a:({type1}, {type2}))\n {{\nvar s = \"\"\n print(a, to:&s)\nwriteToFile(s, \"WrapVirtualTuple{appendage}\")\n }}\n}}\n";
CSLine cstupe = CSVariableDeclaration.VarLine(new CSSimpleType($"MontyWVT{appendage}"), "m", new CSFunctionCall($"MontyWVT{appendage}", true));
CSLine printer = CSFunctionCall.FunctionCallLine("m.Tupe", false,
new CSFunctionCall(String.Format("Tuple<{0},{1}>", cstype1, cstype2), true, new CSIdentifier(val1),
new CSIdentifier(val2)));
CSCodeBlock callingCode = CSCodeBlock.Create(cstupe, printer);
TestRunning.TestAndExecute(swiftCode, callingCode, expected, $"WrapVirtualTuple{appendage}");
}
public void TestGenericConstructorClassHomonym()
{
var swiftCode =
"public class FooGeneric<T> {\n" +
" public var x:Int\n" +
" public var t:T\n" +
" public init(a:Int, c:T) { x = a\n t = c\n}\n" +
" public init(b:Int, c:T) { x = b + b\n t = c\n}\n" +
"}\n";
var call = new CSFunctionCall("FooGeneric<bool>.FooGeneric_a_c", false, CSConstant.Val(14), CSConstant.Val(true));
var call1 = new CSFunctionCall("FooGeneric<bool>.FooGeneric_b_c", false, CSConstant.Val(14), CSConstant.Val(true));
CSLine printer = CSFunctionCall.ConsoleWriteLine(call.Dot(new CSIdentifier("X")));
CSLine printer1 = CSFunctionCall.ConsoleWriteLine(call1.Dot(new CSIdentifier("X")));
CSCodeBlock callingCode = CSCodeBlock.Create(printer, printer1);
TestRunning.TestAndExecute(swiftCode, callingCode, "14\n28\n");
}
public void ClosureSmokeTest()
{
string swiftCode =
"public func callClosureCST(f:@escaping()->()) {\n" +
" f()\n" +
"}";
CodeElementCollection <ICodeElement> callingCode = new CodeElementCollection <ICodeElement> ();
CSCodeBlock body = new CSCodeBlock();
body.Add(CSFunctionCall.ConsoleWriteLine(CSConstant.Val("C# output")));
CSLine invoker = CSFunctionCall.FunctionCallLine("TopLevelEntities.CallClosureCST", false,
new CSLambda(new CSParameterList(), body));
callingCode.Add(invoker);
TestRunning.TestAndExecute(swiftCode, callingCode, "C# output\n");
}
