Initial import.

Author: rolfbjarne

Diff for: .gitignore

@@ -0,0 +1,6 @@
+SwiftToolchain-*
+Constants.cs
+Pack-Man/*
+*.csproj.user
+stconfig.inc
+devicetests-build

Diff for: BUILDING.md

@@ -0,0 +1,67 @@
+# Building Binding Tools for Swift from sources
+
+## Requirements
+
+### Install Xcode
+
+There are two options to installing Xcode:
+
+1. Use automatic provisioning. This is done by executing `make provision` in `maccore/tools/tom-swifty`, but it may take a while to download Xcode unless you're in the Boston office, in which case it might be better to download Xcode manually (next option).
+
+2. Download Xcode manually from https://download.developer.apple.com/Developer_Tools/Xcode_9.2/Xcode_9.2.xip
+
+	1. Extract and copy Xcode_9.2.xip to `/Applications/Xcode_9.2.app` (if you already have Xcode 9.2 in `/Applications/Xcode92.app`, you can just create a symlink: `ln -s /Applications/Xcode92.app /Applications/Xcode_9.2.app`)
+	2. `sudo xcode-select -s /Applications/Xcode_9.2.app/`
+
+### Notes
+
+* there are other requirements (e.g. `cmake`, `ninja`) that I already have, most of them are likely needed to build `xamarin-macios`. It’s possible that I have some for others reasons too. Please update this document if you find any missing requirements.
+
+
+## Building
+
+Create a directory to dedicate to Binding Tools for Swift, e.g.
+
+1. `mkdir ~/git/binding-tools-for-swift`
+2. `cd ~/git/binding-tools-for-swift`
+
+Clone maccore
+
+1. `git clone [email protected]:xamarin/maccore`
+
+Build everything. This will build the swift dependency (only if needed [1]) and binding-tools-for-swift.
+
+1. `cd tools/tom-swifty`
+2. `make`
+
+[1] The build script will first check if a prepackaged version of the swift
+toolchain is available in Azure, and if so, download and use that version.
+This behavior can be overriden by doing `export FORCE_SWIFT_BUILD=1`.
+
+### Notes
+
+The above steps are doing a **full debug** build for swift. [build-script](https://github.com/xamarin/swift/blob/swift-4.0-branch-tomswifty/utils/build-script) can also produce different builds, e.g.
+
+* `-d | --debug`: full debug (like above)
+* `-R | --release`: release
+* `-r | --release-debuginfo`: release with debug info
+
+Running `build-script` takes a **very long** time, so building extraneous local configurations is optional.
+
+### Running Unit Tests
+
+1. `cd maccore/tools/tom-swifty/tests/tom-swifty-test/`
+2. `make`
+
+### Notes
+
+* The new (incompatible but much more powerful) NUnit 3 runner means using the usual `FIXTURES` variable has to use a [different syntax](https://github.com/nunit/docs/wiki/Test-Selection-Language). E.g. to run a single test case from the command line you would do
+
+```
+FIXTURES="--where=test=SwiftReflector.LinkageTests.TestMissingNSObject" make
+```
+
+
+## Generated Source Files
+- `SwiftReflector/IOUtils/SwiftModuleList.g.cs` is generated via the `update_module_list.csharp` script. 
+	- `./update_module_list.csharp SwiftToolchain-v2-8efccc1464890d6c906fb2c40f909b5324da950d`

Diff for: Constants.cs.in

@@ -0,0 +1,5 @@
+static class Constants {
+	public const string Version = "@VERSION@";
+	public const string Branch = "@BRANCH@";
+	public const string Hash = "@HASH@";
+}

Diff for: Dynamo/CodeElementCollection.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Dynamo {
+	public class CodeElementCollection<T> : List<T>, ICodeElementSet where T : ICodeElement {
+		public CodeElementCollection () : base ()
+		{
+		}
+
+		#region ICodeElem implementation
+
+		public event EventHandler<WriteEventArgs> Begin = (s, e) => { };
+
+		public event EventHandler<WriteEventArgs> End = (s, e) => { };
+
+		public virtual object BeginWrite (ICodeWriter writer)
+		{
+			OnBeginWrite (new WriteEventArgs (writer));
+			return null;
+		}
+
+		protected virtual void OnBeginWrite (WriteEventArgs args)
+		{
+			Begin (this, args);
+		}
+
+		public virtual void Write (ICodeWriter writer, object o)
+		{
+		}
+
+		public virtual void EndWrite (ICodeWriter writer, object o)
+		{
+			OnEndWrite (new WriteEventArgs (writer));
+		}
+
+		protected virtual void OnEndWrite (WriteEventArgs args)
+		{
+			End.FireInReverse (this, args);
+		}
+
+
+		#endregion
+
+		#region ICodeElemSet implementation
+
+		public System.Collections.Generic.IEnumerable<ICodeElement> Elements {
+			get {
+				return this.Cast<ICodeElement> ();
+			}
+		}
+
+		#endregion
+
+	}
+}
+

Diff for: Dynamo/CodeWriter.cs

@@ -0,0 +1,146 @@
+using System;
+using System.Globalization;
+using System.IO;
+
+namespace Dynamo {
+	public class CodeWriter : ICodeWriter {
+		int charsWrittenThisLine;
+		bool indentedThisLine;
+
+		const int kSpacesPerIndent = 4;
+		const int kWrapPoint = 60;
+
+		public CodeWriter (Stream stm)
+			: this (new StreamWriter (Exceptions.ThrowOnNull (stm, "stm")))
+		{
+		}
+
+		public CodeWriter (TextWriter tw)
+		{
+			TextWriter = Exceptions.ThrowOnNull (tw, "tw");
+			charsWrittenThisLine = 0;
+			IndentLevel = 0;
+			IsAtLineStart = true;
+		}
+
+		public static void WriteToFile (string fileName, ICodeElement element)
+		{
+			using (var stm = new FileStream (fileName, FileMode.Create)) {
+				CodeWriter writer = new CodeWriter (stm);
+				element.WriteAll (writer);
+				writer.TextWriter.Flush ();
+			}
+		}
+
+		public static Stream WriteToStream (ICodeElement element)
+		{
+			var stm = new MemoryStream ();
+			var codeWriter = new CodeWriter (stm);
+			element.WriteAll (codeWriter);
+			codeWriter.TextWriter.Flush ();
+			stm.Flush ();
+			stm.Seek (0, SeekOrigin.Begin);
+			return stm;
+		}
+
+		public static string WriteToString (ICodeElement element)
+		{
+			using (var reader = new StreamReader (WriteToStream (element)))
+				return reader.ReadToEnd ();
+		}
+
+		public TextWriter TextWriter { get; private set; }
+
+		#region ICodeWriter implementation
+
+		public void BeginNewLine (bool prependIndents)
+		{
+			Write (Environment.NewLine, false);
+			if (prependIndents)
+				WriteIndents ();
+			IsAtLineStart = true;
+		}
+
+		public void EndLine ()
+		{
+			charsWrittenThisLine = 0;
+			if (indentedThisLine) {
+				indentedThisLine = false;
+				// strictly speaking, this test shouldn't be necessary
+				if (IndentLevel > 0)
+					Exdent ();
+			}
+		}
+
+		public bool IsAtLineStart { get; private set; }
+
+		public void Write (string code, bool allowSplit)
+		{
+			var characterEnum = StringInfo.GetTextElementEnumerator (code);
+			while (characterEnum.MoveNext ()) {
+				string c = characterEnum.GetTextElement ();
+				WriteUnicode (c, allowSplit);
+			}
+		}
+
+		public void Write (char c, bool allowSplit)
+		{
+			Write (c.ToString (), allowSplit);
+		}
+
+		void WriteUnicode (string c, bool allowSplit)
+		{
+			var info = new StringInfo (c);
+			if (info.LengthInTextElements > 1)
+				throw new ArgumentOutOfRangeException (nameof (c), $"Expected a single unicode value but got '{c}'");
+			WriteNoBookKeeping (c);
+			IsAtLineStart = false;
+			charsWrittenThisLine++;
+			if (allowSplit && charsWrittenThisLine > kWrapPoint && IsWhiteSpace (c)) {
+				if (!indentedThisLine) {
+					Indent ();
+					indentedThisLine = true;
+				}
+				WriteNoBookKeeping (Environment.NewLine);
+				charsWrittenThisLine = 0;
+				WriteIndents ();
+				IsAtLineStart = true;
+			}
+		}
+
+		bool IsWhiteSpace (string c) {
+			return c.Length == 1 && Char.IsWhiteSpace (c[0]);
+
+		}
+
+		void WriteNoBookKeeping (string s)
+		{
+			TextWriter.Write (s);
+		}
+
+		void WriteIndents ()
+		{
+			int totalSpaces = IndentLevel * kSpacesPerIndent;
+			// know what's embarrassing? When your indents cause breaks which generates more indents.
+			for (int i = 0; i < totalSpaces; i++)
+				Write (" ", false);
+		}
+
+		public void Indent ()
+		{
+			IndentLevel++;
+		}
+
+		public void Exdent ()
+		{
+			if (IndentLevel == 0)
+				throw new Exception ("IndentLevel is at 0.");
+			IndentLevel--;
+		}
+
+		public int IndentLevel { get; private set; }
+
+		#endregion
+	}
+}
+

Diff for: Dynamo/CommaListElementCollection.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+
+namespace Dynamo {
+	public class CommaListElementCollection<T> : List<T>, ICodeElement where T : ICodeElement {
+		public CommaListElementCollection ()
+			: this ("", "")
+		{
+		}
+
+
+		public CommaListElementCollection (IEnumerable<T> objs)
+			: this ("", "", objs)
+		{
+		}
+
+		public CommaListElementCollection (string prefix, string suffix)
+			: base ()
+		{
+			Prefix = Exceptions.ThrowOnNull (prefix, nameof (prefix));
+			Suffix = Exceptions.ThrowOnNull (suffix, nameof (suffix));
+		}
+
+		public CommaListElementCollection (string prefix, string suffix, IEnumerable<T> objs, bool newlineAfterEach = false)
+			: this (prefix, suffix)
+		{
+			AddRange (Exceptions.ThrowOnNull (objs, nameof (objs)));
+			NewlineAfterEach = newlineAfterEach;
+		}
+
+
+		public string Prefix { get; private set; }
+		public string Suffix { get; private set; }
+		public bool NewlineAfterEach { get; private set; }
+
+		#region ICodeElem implementation
+
+		public event EventHandler<WriteEventArgs> Begin = (s, e) => { };
+
+		public event EventHandler<WriteEventArgs> End = (s, e) => { };
+
+		public object BeginWrite (ICodeWriter writer)
+		{
+			OnBegin (new WriteEventArgs (writer));
+			return null;
+		}
+
+		protected virtual void OnBegin (WriteEventArgs args)
+		{
+			Begin (this, args);
+		}
+
+		public void Write (ICodeWriter writer, object o)
+		{
+			writer.Write (Prefix, true);
+			for (int i = 0; i < Count; i++) {
+				this [i].WriteAll (writer);
+				if (i < Count - 1)
+					writer.Write (", ", true);
+				if (NewlineAfterEach && !writer.IsAtLineStart) {
+					writer.BeginNewLine (true);
+				}
+			}
+			writer.Write (Suffix, true);
+		}
+
+		public void EndWrite (ICodeWriter writer, object o)
+		{
+			OnEnd (new WriteEventArgs (writer));
+		}
+
+
+		protected virtual void OnEnd (WriteEventArgs args)
+		{
+			End.FireInReverse (this, args);
+		}
+
+		#endregion
+	}
+}
+