1 files changed, 275 insertions, 0 deletions

diff --git a/src/api/wix/WixToolset.Data/SourceLineNumber.cs b/src/api/wix/WixToolset.Data/SourceLineNumber.cs
new file mode 100644
index 00000000..970f17e7
--- /dev/null
+++ b/src/api/wix/WixToolset.Data/SourceLineNumber.cs
@@ -0,0 +1,275 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Data
+{
+    using System;
+    using System.IO;
+    using System.Text;
+    using System.Xml;
+    using System.Xml.Linq;
+    using SimpleJson;
+
+    /// <summary>
+    /// Represents file name and line number for source file
+    /// </summary>
+    public sealed class SourceLineNumber
+    {
+        /// <summary>
+        /// Constructor for a source with no line information.
+        /// </summary>
+        /// <param name="fileName">File name of the source.</param>
+        public SourceLineNumber(string fileName)
+        {
+            this.FileName = fileName;
+        }
+
+        /// <summary>
+        /// Constructor for a source with line information.
+        /// </summary>
+        /// <param name="fileName">File name of the source.</param>
+        /// <param name="lineNumber">Line number of the source.</param>
+        public SourceLineNumber(string fileName, int lineNumber)
+        {
+            this.FileName = fileName;
+            this.LineNumber = lineNumber;
+        }
+
+        /// <summary>
+        /// Constructor for a source with a parent and no line information.
+        /// </summary>
+        /// <param name="fileName">File name of the source.</param>
+        /// <param name="parent">Parent of this source line number</param>
+        public SourceLineNumber(string fileName, SourceLineNumber parent)
+        {
+            this.FileName = fileName;
+            this.Parent = parent;
+        }
+
+        /// <summary>
+        /// Constructor for a source with a parent and line information.
+        /// </summary>
+        /// <param name="fileName">File name of the source.</param>
+        /// <param name="parent">Parent of this source line number</param>
+        /// <param name="lineNumber">Line number of the source.</param>
+        public SourceLineNumber(string fileName, SourceLineNumber parent, int lineNumber)
+        {
+            this.FileName = fileName;
+            this.Parent = parent;
+            this.LineNumber = lineNumber;
+        }
+
+        /// <summary>
+        /// Gets the file name of the source.
+        /// </summary>
+        /// <value>File name for the source.</value>
+        public string FileName { get; }
+
+        /// <summary>
+        /// Gets or sets the line number of the source.
+        /// </summary>
+        /// <value>Line number of the source.</value>
+        public int? LineNumber { get; set; }
+
+        /// <summary>
+        /// Gets or sets the parent source line number that included this source line number.
+        /// </summary>
+        public SourceLineNumber Parent { get; private set; }
+
+        /// <summary>
+        /// Gets the file name and line information.
+        /// </summary>
+        /// <value>File name and line information.</value>
+        public string QualifiedFileName => this.LineNumber.HasValue ? String.Concat(this.FileName, "*", this.LineNumber) : this.FileName;
+
+        internal static SourceLineNumber Deserialize(JsonObject jsonObject)
+        {
+            var fileName = jsonObject.GetValueOrDefault<string>("file");
+            var lineNumber = jsonObject.GetValueOrDefault("line", null);
+
+            var parentJson = jsonObject.GetValueOrDefault<JsonObject>("parent");
+            var parent = (parentJson == null) ? null : SourceLineNumber.Deserialize(parentJson);
+
+            return new SourceLineNumber(fileName)
+            {
+                LineNumber = lineNumber,
+                Parent = parent
+            };
+        }
+
+        internal JsonObject Serialize()
+        {
+            var jsonObject = new JsonObject
+            {
+                { "file", this.FileName },
+                { "line", this.LineNumber }
+            };
+
+            if (this.Parent != null)
+            {
+                var parentJson = this.Parent.Serialize();
+                jsonObject.Add("parent", parentJson);
+            }
+
+            return jsonObject;
+        }
+
+        /// <summary>
+        /// Creates a source line number from an encoded string.
+        /// </summary>
+        /// <param name="encodedSourceLineNumbers">Encoded string to parse.</param>
+        public static SourceLineNumber CreateFromEncoded(string encodedSourceLineNumbers)
+        {
+            var linesSplitIndex = encodedSourceLineNumbers.IndexOf('|');
+
+            // The most common case is that there is a single encoded line,
+            // so optimize for that case.
+            if (linesSplitIndex < 0)
+            {
+                return DecodeSourceLineNumber(encodedSourceLineNumbers, 0, -1);
+            }
+            else // decode the multiple lines.
+            {
+                var startLine = 0;
+
+                SourceLineNumber first = null;
+                SourceLineNumber parent = null;
+                while (startLine < encodedSourceLineNumbers.Length)
+                {
+                    var source = DecodeSourceLineNumber(encodedSourceLineNumbers, startLine, linesSplitIndex - 1);
+
+                    if (null != parent)
+                    {
+                        parent.Parent = source;
+                    }
+
+                    parent = source;
+                    if (null == first)
+                    {
+                        first = parent;
+                    }
+
+                    if (linesSplitIndex < 0)
+                    {
+                        break;
+                    }
+
+                    startLine = linesSplitIndex + 1;
+                    linesSplitIndex = encodedSourceLineNumbers.IndexOf('|', startLine);
+                }
+
+                return first;
+            }
+        }
+
+        /// <summary>
+        /// Creates a source line number from a URI.
+        /// </summary>
+        /// <param name="uri">Uri to convert into source line number</param>
+        public static SourceLineNumber CreateFromUri(string uri)
+        {
+            if (String.IsNullOrEmpty(uri))
+            {
+                return null;
+            }
+
+            // make the local path look like a normal local path
+            var localPath = new Uri(uri).LocalPath;
+            localPath = localPath.TrimStart(Path.AltDirectorySeparatorChar).Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+
+            return new SourceLineNumber(localPath);
+        }
+
+        /// <summary>
+        /// Creates a source line number from an XObject.
+        /// </summary>
+        /// <param name="node">XML node to create source line number from.</param>
+        /// <param name="offset">Optional line number offset into XML file not already included in the line information.</param>
+        public static SourceLineNumber CreateFromXObject(XObject node, int offset = 0)
+        {
+            var result = CreateFromUri(node.BaseUri);
+            if (null != result && node is IXmlLineInfo lineInfo)
+            {
+                result.LineNumber = lineInfo.LineNumber + offset;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Get the source line information for the current element. Typically this information 
+        /// is set by the precompiler for each element that it encounters.
+        /// </summary>
+        /// <param name="node">Element to get source line information for.</param>
+        /// <returns>
+        /// The source line number used to author the element being processed or
+        /// null if the preprocessor did not process the element or the node is
+        /// not an element.
+        /// </returns>
+        public static SourceLineNumber GetFromXAnnotation(XObject node)
+        {
+            return node.Annotation<SourceLineNumber>();
+        }
+
+        /// <summary>
+        /// Returns the SourceLineNumber and parents encoded as a string.
+        /// </summary>
+        public string GetEncoded()
+        {
+            var sb = new StringBuilder(this.QualifiedFileName);
+
+            for (var parent = this.Parent; null != parent; parent = parent.Parent)
+            {
+                sb.Append("|");
+                sb.Append(parent.QualifiedFileName);
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Determines if two SourceLineNumbers are equivalent.
+        /// </summary>
+        /// <param name="obj">Object to compare.</param>
+        /// <returns>True if SourceLineNumbers are equivalent.</returns>
+        public override bool Equals(object obj)
+        {
+            return obj is SourceLineNumber other &&
+                   this.LineNumber.HasValue == other.LineNumber.HasValue &&
+                   (!this.LineNumber.HasValue || this.LineNumber == other.LineNumber) &&
+                   this.FileName.Equals(other.FileName, StringComparison.OrdinalIgnoreCase) &&
+                   (null == this.Parent && null == other.Parent || this.Parent.Equals(other.Parent));
+        }
+
+        /// <summary>
+        /// Serves as a hash code for a particular type.
+        /// </summary>
+        /// <returns>The hash code.</returns>
+        public override int GetHashCode()
+        {
+            return this.GetEncoded().GetHashCode();
+        }
+
+        /// <summary>
+        /// Shows a string representation of a source line number.
+        /// </summary>
+        /// <returns>String representation of a source line number.</returns>
+        public override string ToString()
+        {
+            return this.LineNumber.HasValue && !String.IsNullOrEmpty(this.FileName) ? String.Concat(this.FileName, "(", this.LineNumber, ")") : this.FileName ?? String.Empty;
+        }
+
+        private static SourceLineNumber DecodeSourceLineNumber(string encoded, int startIndex, int endIndex)
+        {
+            if (endIndex < 0)
+            {
+                endIndex = encoded.Length - 1;
+            }
+
+            var count = endIndex - startIndex;
+            var filenameSplitIndex = encoded.LastIndexOf('*', endIndex - 1, count);
+            return (filenameSplitIndex < 0) ? new SourceLineNumber(encoded) :
+                                              new SourceLineNumber(encoded.Substring(startIndex, filenameSplitIndex - startIndex),
+                                                                   Convert.ToInt32(encoded.Substring(filenameSplitIndex + 1, endIndex - filenameSplitIndex)));
+        }
+    }
+}