public void SmokeTestOverride0() { string code = "open class Foo { public init() { }\nopen func doSomething() { }\n}\n"; List <ClassDeclaration> classes = ReflectClassDeclarations(code); Assert.AreEqual(1, classes.Count); ClassDeclaration theClass = classes [0].MakeUnrooted() as ClassDeclaration; TypeMapper typeMapper = new TypeMapper(Compiler.kTypeDatabases, UnicodeMapper.Default); typeMapper.RegisterClass(theClass); OverrideBuilder overrider = new OverrideBuilder(typeMapper, theClass, null, new ModuleDeclaration("OverrideModule")); Assert.IsNotNull(overrider.OverriddenClass); Assert.AreEqual(1, overrider.ClassImplementations.Count); Assert.IsNotNull(overrider.OverriddenVirtualMethods); Assert.AreEqual(1, overrider.OverriddenVirtualMethods.Count); using (TempDirectoryFilenameProvider temp = new TempDirectoryFilenameProvider(null, false)) { string file = temp.ProvideFileFor("output.swift"); SLFile swiftFile = new SLFile(overrider.Imports); swiftFile.Classes.AddRange(overrider.ClassImplementations); CodeWriter.WriteToFile(file, swiftFile); } }
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); } }
static void PropertyTestCore(string simpleClass) { using (TempDirectoryFilenameProvider provider = new TempDirectoryFilenameProvider()) { Utils.CompileSwift(simpleClass, provider); string libFileName = Path.Combine(provider.DirectoryPath, "libXython.dylib"); var errors = new ErrorHandling(); ModuleInventory inventory = ModuleInventory.FromFile(libFileName, errors); Utils.CheckErrors(errors); Utils.CompileToCSharp(provider); } }
List <ClassDeclaration> ReflectClassDeclarations(string code) { using (TempDirectoryFilenameProvider fileProvider = new TempDirectoryFilenameProvider(null, false)) { CustomSwiftCompiler compiler = Utils.DefaultSwiftCompiler(fileProvider); SwiftCompilerOptions options = new SwiftCompilerOptions("NameNotImportant", null, null, null); compiler.CompileString(options, code); List <ModuleDeclaration> modules = compiler.ReflectToModules(new string [] { compiler.DirectoryPath }, new string [] { compiler.DirectoryPath }, "", "NameNotImportant"); Assert.AreEqual(1, modules.Count); return(modules [0].AllClasses); } }
string RunBindingToolsForSwift(string swiftCode, string testName = null) { var nameSpace = "OutputTests"; using (TempDirectoryFilenameProvider provider = new TempDirectoryFilenameProvider()) { var compiler = Utils.CompileSwift(swiftCode, provider, nameSpace); var libName = $"lib{nameSpace}.dylib"; using (DisposableTempDirectory temp = new DisposableTempDirectory()) { File.Copy(Path.Combine(compiler.DirectoryPath, libName), Path.Combine(temp.DirectoryPath, libName)); return(Utils.CompileToCSharp(provider, temp.DirectoryPath, nameSpace, separateProcess: true)); } } }
public ObjCProtocolCompiler(PlatformName targetPlatform, IEnumerable <ProtocolDeclaration> protocols, TempDirectoryFilenameProvider provider, ModuleDeclaration module, string swiftLibPath, string outputDirectory, TypeMapper typeMapper, WrappingResult wrapper, ErrorHandling errors, bool verbose) { this.targetPlatform = targetPlatform; this.protocols = protocols.Where(p => p.IsObjC && p.IsPublicOrOpen && !p.IsUnavailable && !p.IsDeprecated).ToList(); this.provider = provider; this.module = module; this.swiftLibPath = swiftLibPath; this.outputDirectory = outputDirectory; this.typeMapper = typeMapper; this.wrapper = wrapper; this.errors = errors; this.verbose = verbose; topLevelFunctionCompiler = new TopLevelFunctionCompiler(this.typeMapper); }