From 16e274d29ae88961d26650dc10abde8d3e967313 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@users.noreply.github.com>
Date: Fri, 20 Jul 2018 10:37:55 +0200
Subject: [PATCH 1/6] Added some unit tests for #1764.

---
 .../Xaml/BindingTests.cs                      | 29 ++++++++++++++++++-
 .../Xaml/StyleTests.cs                        | 28 +++++++++++++++++-
 2 files changed, 55 insertions(+), 2 deletions(-)

diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs
index 568c6482f5..f327e9ccf2 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs
@@ -281,5 +281,32 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                 Assert.Equal(5.6, AttachedPropertyOwner.GetDouble(textBlock));
             }
         }
+
+        [Fact]
+        public void Binding_To_Attached_Property_In_Style_Works()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
+    <Window.Styles>
+        <Style Selector='TextBlock'>
+            <Setter Property='local:TestControl.Double' Value='{Binding}'/>
+        </Style>
+    </Window.Styles>
+    <TextBlock/>
+</Window>";
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var textBlock = (TextBlock)window.Content;
+
+                window.DataContext = 5.6;
+                window.ApplyTemplate();
+
+                Assert.Equal(5.6, AttachedPropertyOwner.GetDouble(textBlock));
+            }
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
index 2c7e850fee..4517aa6aa1 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
@@ -146,5 +146,31 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                 Assert.NotNull(target.FocusAdorner);
             }
         }
+
+        [Fact]
+        public void Setter_Can_Set_Attached_Property()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
+    <Window.Styles>
+        <Style Selector='TextBlock'>
+            <Setter Property='DockPanel.Dock' Value='Right'/>
+        </Style>
+    </Window.Styles>
+    <TextBlock/>
+</Window>";
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var textBlock = (TextBlock)window.Content;
+
+                window.ApplyTemplate();
+
+                Assert.Equal(Dock.Right, DockPanel.GetDock(textBlock));
+            }
+        }
     }
-}
\ No newline at end of file
+}

From ffcaa545bb64db5489de3cb135e4f831afb07a8f Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@users.noreply.github.com>
Date: Fri, 20 Jul 2018 10:45:07 +0200
Subject: [PATCH 2/6] Added PropertyParser.

So we don't need to use a regex to parse property strings.
---
 .../Avalonia.Markup.Xaml.csproj               |   1 +
 .../Parsers/PropertyParser.cs                 |  84 +++++++
 .../Markup/Parsers/IdentifierParser.cs        |   2 +-
 .../Avalonia.Markup/Markup/Parsers/Reader.cs  |   2 +-
 .../Parsers/PropertyParserTests.cs            | 225 ++++++++++++++++++
 5 files changed, 312 insertions(+), 2 deletions(-)
 create mode 100644 src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs
 create mode 100644 tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs

diff --git a/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj b/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj
index cdc22f4102..8c843a4b49 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj
+++ b/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj
@@ -33,6 +33,7 @@
         <Compile Include="MarkupExtensions\ResourceInclude.cs" />
         <Compile Include="MarkupExtensions\StaticResourceExtension.cs" />
         <Compile Include="MarkupExtensions\StyleIncludeExtension.cs" />
+        <Compile Include="Parsers\PropertyParser.cs" />
         <Compile Include="PortableXaml\AvaloniaXamlContext.cs" />
         <Compile Include="PortableXaml\AttributeExtensions.cs" />
         <Compile Include="PortableXaml\AvaloniaMemberAttributeProvider.cs" />
diff --git a/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs b/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs
new file mode 100644
index 0000000000..ce82ffe0a1
--- /dev/null
+++ b/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs
@@ -0,0 +1,84 @@
+using System;
+using Avalonia.Data.Core;
+using Avalonia.Markup.Parsers;
+
+namespace Avalonia.Markup.Xaml.Parsers
+{
+    internal class PropertyParser
+    {
+        public (string ns, string owner, string name) Parse(Reader r)
+        {
+            if (r.End)
+            {
+                throw new ExpressionParseException(0, "Expected property name.");
+            }
+
+            var openParens = r.TakeIf('(');
+            bool closeParens = false;
+            string ns = null;
+            string owner = null;
+            string name = null;
+
+            do
+            {
+                var token = IdentifierParser.Parse(r);
+
+                if (token == null)
+                {
+                    if (r.End)
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        if (openParens && !r.End && (closeParens = r.TakeIf(')')))
+                        {
+                            break;
+                        }
+                        else if (openParens)
+                        {
+                            throw new ExpressionParseException(r.Position, $"Expected ')'.");
+                        }
+
+                        throw new ExpressionParseException(r.Position, $"Unexpected '{r.Peek}'.");
+                    }
+                }
+                else if (!r.End && r.TakeIf(':'))
+                {
+                    ns = ns == null ?
+                        token :
+                        throw new ExpressionParseException(r.Position, "Unexpected ':'.");
+                }
+                else if (!r.End && r.TakeIf('.'))
+                {
+                    owner = owner == null ?
+                        token :
+                        throw new ExpressionParseException(r.Position, "Unexpected '.'.");
+                }
+                else
+                {
+                    name = token;
+                }
+            } while (!r.End);
+
+            if (name == null)
+            {
+                throw new ExpressionParseException(0, "Expected property name.");
+            }
+            else if (openParens && owner == null)
+            {
+                throw new ExpressionParseException(1, "Expected property owner.");
+            }
+            else if (openParens && !closeParens)
+            {
+                throw new ExpressionParseException(r.Position, "Expected ')'.");
+            }
+            else if (!r.End)
+            {
+                throw new ExpressionParseException(r.Position, "Expected end of expression.");
+            }
+
+            return (ns, owner, name);
+        }
+    }
+}
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs
index f86f2db321..9431dab45e 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs
@@ -6,7 +6,7 @@ using System.Text;
 
 namespace Avalonia.Markup.Parsers
 {
-    internal static class IdentifierParser
+    public static class IdentifierParser
     {
         public static string Parse(Reader r)
         {
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs
index 9355bc9aa3..4a3d6aa277 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs
@@ -5,7 +5,7 @@ using System;
 
 namespace Avalonia.Markup.Parsers
 {
-    internal class Reader
+    public class Reader
     {
         private readonly string _s;
         private int _i;
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs
new file mode 100644
index 0000000000..a05485f55b
--- /dev/null
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs
@@ -0,0 +1,225 @@
+using System;
+using Avalonia.Data.Core;
+using Avalonia.Markup.Parsers;
+using Avalonia.Markup.Xaml.Parsers;
+using Xunit;
+
+namespace Avalonia.Markup.Xaml.UnitTests.Parsers
+{
+    public class PropertyParserTests
+    {
+        [Fact]
+        public void Parses_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("Foo");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Null(ns);
+            Assert.Null(owner);
+            Assert.Equal("Foo", name);
+        }
+
+        [Fact]
+        public void Parses_Owner_And_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("Foo.Bar");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Null(ns);
+            Assert.Equal("Foo", owner);
+            Assert.Equal("Bar", name);
+        }
+
+        [Fact]
+        public void Parses_Namespace_Owner_And_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("foo:Bar.Baz");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Equal("foo", ns);
+            Assert.Equal("Bar", owner);
+            Assert.Equal("Baz", name);
+        }
+
+        [Fact]
+        public void Parses_Owner_And_Name_With_Parentheses()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("(Foo.Bar)");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Null(ns);
+            Assert.Equal("Foo", owner);
+            Assert.Equal("Bar", name);
+        }
+
+        [Fact]
+        public void Parses_Namespace_Owner_And_Name_With_Parentheses()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("(foo:Bar.Baz)");
+            var (ns, owner, name) = target.Parse(reader);
+
+            Assert.Equal("foo", ns);
+            Assert.Equal("Bar", owner);
+            Assert.Equal("Baz", name);
+        }
+
+        [Fact]
+        public void Fails_With_Empty_String()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(0, ex.Column);
+            Assert.Equal("Expected property name.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Only_Whitespace()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("  ");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(0, ex.Column);
+            Assert.Equal("Unexpected ' '.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Leading_Whitespace()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader(" Foo");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(0, ex.Column);
+            Assert.Equal("Unexpected ' '.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Trailing_Whitespace()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("Foo ");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(3, ex.Column);
+            Assert.Equal("Unexpected ' '.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Invalid_Property_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("123");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(0, ex.Column);
+            Assert.Equal("Unexpected '1'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Trailing_Junk()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("Foo%");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(3, ex.Column);
+            Assert.Equal("Unexpected '%'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Invalid_Property_Name_After_Owner()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("Foo.123");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(4, ex.Column);
+            Assert.Equal("Unexpected '1'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Whitespace_Between_Owner_And_Name()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("Foo. Bar");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(4, ex.Column);
+            Assert.Equal("Unexpected ' '.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Too_Many_Segments()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("Foo.Bar.Baz");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(8, ex.Column);
+            Assert.Equal("Unexpected '.'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Too_Many_Namespaces()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("foo:bar:Baz");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(8, ex.Column);
+            Assert.Equal("Unexpected ':'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Parens_But_No_Owner()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("(Foo)");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(1, ex.Column);
+            Assert.Equal("Expected property owner.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Parens_And_Namespace_But_No_Owner()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("(foo:Bar)");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(1, ex.Column);
+            Assert.Equal("Expected property owner.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Missing_Close_Parens()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("(Foo.Bar");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(8, ex.Column);
+            Assert.Equal("Expected ')'.", ex.Message);
+        }
+
+        [Fact]
+        public void Fails_With_Unexpected_Close_Parens()
+        {
+            var target = new PropertyParser();
+            var reader = new Reader("Foo.Bar)");
+
+            var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
+            Assert.Equal(7, ex.Column);
+            Assert.Equal("Unexpected ')'.", ex.Message);
+        }
+    }
+}

From 0b796adc53f923208b41991b6806141492dac8a2 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@users.noreply.github.com>
Date: Fri, 20 Jul 2018 10:57:43 +0200
Subject: [PATCH 3/6] Fix a few issues with AvaloniaPropertyTypeConverter

- Don't use regex to parse property strings, use `PropertyParser`
- Handle XAML namespaces on attached properties

Fixes #1764
---
 .../AvaloniaPropertyTypeConverter.cs          | 37 ++++++-------------
 1 file changed, 11 insertions(+), 26 deletions(-)

diff --git a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
index 63b7811dbc..6cdf0452d0 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
@@ -4,19 +4,16 @@
 using System;
 using System.ComponentModel;
 using System.Globalization;
-using System.Text.RegularExpressions;
+using Avalonia.Markup.Parsers;
+using Avalonia.Markup.Xaml.Parsers;
 using Avalonia.Markup.Xaml.Templates;
 using Avalonia.Styling;
-using Portable.Xaml;
 using Portable.Xaml.ComponentModel;
-using Portable.Xaml.Markup;
 
 namespace Avalonia.Markup.Xaml.Converters
 {
     public class AvaloniaPropertyTypeConverter : TypeConverter
     {
-        private static readonly Regex regex = new Regex(@"^\(?(\w*)\.(\w*)\)?|(.*)$");
-
         public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
         {
             return sourceType == typeof(string);
@@ -24,8 +21,10 @@ namespace Avalonia.Markup.Xaml.Converters
 
         public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
         {
-            var (owner, propertyName) = ParseProperty((string)value);
-            var ownerType = TryResolveOwnerByName(context, owner) ??
+            var parser = new PropertyParser();
+            var reader = new Reader((string)value);
+            var (ns, owner, propertyName) = parser.Parse(reader);
+            var ownerType = TryResolveOwnerByName(context, ns, owner) ??
                 context.GetFirstAmbientValue<ControlTemplate>()?.TargetType ??
                 context.GetFirstAmbientValue<Style>()?.Selector?.TargetType;
 
@@ -47,16 +46,16 @@ namespace Avalonia.Markup.Xaml.Converters
             return property;
         }
 
-        private Type TryResolveOwnerByName(ITypeDescriptorContext context, string owner)
+        private Type TryResolveOwnerByName(ITypeDescriptorContext context, string ns, string owner)
         {
             if (owner != null)
             {
-                var resolver = context.GetService<IXamlTypeResolver>();
-                var result = resolver.Resolve(owner);
+                var result = context.ResolveType(ns, owner);
 
                 if (result == null)
                 {
-                    throw new XamlLoadException($"Could not find type '{owner}'.");
+                    var name = string.IsNullOrEmpty(ns) ? owner : $"{ns}:{owner}";
+                    throw new XamlLoadException($"Could not find type '{name}'.");
                 }
 
                 return result;
@@ -64,19 +63,5 @@ namespace Avalonia.Markup.Xaml.Converters
 
             return null;
         }
-
-        private (string owner, string property) ParseProperty(string s)
-        {
-            var result = regex.Match(s);
-
-            if (result.Groups[1].Success)
-            {
-                return (result.Groups[1].Value, result.Groups[2].Value);
-            }
-            else
-            {
-                return (null, result.Groups[3].Value);
-            }
-        }
     }
-}
\ No newline at end of file
+}

From 5210926c03146492258bceb33ecf60a299e12652 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@users.noreply.github.com>
Date: Fri, 20 Jul 2018 20:22:58 +0200
Subject: [PATCH 4/6] Disallow setting unregistered properties.

---
 src/Avalonia.Base/AvaloniaPropertyRegistry.cs | 52 ++-----------------
 .../AvaloniaPropertyTypeConverter.cs          | 26 +++++-----
 .../AvaloniaPropertyRegistryTests.cs          | 11 ----
 .../AvaloniaPropertyConverterTest.cs          | 36 +++++++++++--
 .../Xaml/StyleTests.cs                        | 26 ++++++++++
 5 files changed, 75 insertions(+), 76 deletions(-)

diff --git a/src/Avalonia.Base/AvaloniaPropertyRegistry.cs b/src/Avalonia.Base/AvaloniaPropertyRegistry.cs
index c0a4ace6ed..e29e7339ae 100644
--- a/src/Avalonia.Base/AvaloniaPropertyRegistry.cs
+++ b/src/Avalonia.Base/AvaloniaPropertyRegistry.cs
@@ -106,7 +106,7 @@ namespace Avalonia
         }
 
         /// <summary>
-        /// Finds a registered non-attached property on a type by name.
+        /// Finds a registered property on a type by name.
         /// </summary>
         /// <param name="type">The type.</param>
         /// <param name="name">The property name.</param>
@@ -130,7 +130,7 @@ namespace Avalonia
         }
 
         /// <summary>
-        /// Finds a registered non-attached property on a type by name.
+        /// Finds a registered property on an object by name.
         /// </summary>
         /// <param name="o">The object.</param>
         /// <param name="name">The property name.</param>
@@ -148,52 +148,6 @@ namespace Avalonia
             return FindRegistered(o.GetType(), name);
         }
 
-        /// <summary>
-        /// Finds a registered attached property on a type by name.
-        /// </summary>
-        /// <param name="type">The type.</param>
-        /// <param name="ownerType">The owner type.</param>
-        /// <param name="name">The property name.</param>
-        /// <returns>
-        /// The registered property or null if no matching property found.
-        /// </returns>
-        /// <exception cref="InvalidOperationException">
-        /// The property name contains a '.'.
-        /// </exception>
-        public AvaloniaProperty FindRegisteredAttached(Type type, Type ownerType, string name)
-        {
-            Contract.Requires<ArgumentNullException>(type != null);
-            Contract.Requires<ArgumentNullException>(ownerType != null);
-            Contract.Requires<ArgumentNullException>(name != null);
-
-            if (name.Contains('.'))
-            {
-                throw new InvalidOperationException("Attached properties not supported.");
-            }
-
-            return GetRegisteredAttached(type).FirstOrDefault(x => x.Name == name);
-        }
-
-        /// <summary>
-        /// Finds a registered non-attached property on a type by name.
-        /// </summary>
-        /// <param name="o">The object.</param>
-        /// <param name="ownerType">The owner type.</param>
-        /// <param name="name">The property name.</param>
-        /// <returns>
-        /// The registered property or null if no matching property found.
-        /// </returns>
-        /// <exception cref="InvalidOperationException">
-        /// The property name contains a '.'.
-        /// </exception>
-        public AvaloniaProperty FindRegisteredAttached(AvaloniaObject o, Type ownerType, string name)
-        {
-            Contract.Requires<ArgumentNullException>(o != null);
-            Contract.Requires<ArgumentNullException>(name != null);
-
-            return FindRegisteredAttached(o.GetType(), ownerType, name);
-        }
-
         /// <summary>
         /// Checks whether a <see cref="AvaloniaProperty"/> is registered on a type.
         /// </summary>
@@ -287,4 +241,4 @@ namespace Avalonia
             _attachedCache.Clear();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
index 6cdf0452d0..2470778685 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
@@ -4,6 +4,7 @@
 using System;
 using System.ComponentModel;
 using System.Globalization;
+using Avalonia.Controls;
 using Avalonia.Markup.Parsers;
 using Avalonia.Markup.Xaml.Parsers;
 using Avalonia.Markup.Xaml.Templates;
@@ -21,26 +22,27 @@ namespace Avalonia.Markup.Xaml.Converters
 
         public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
         {
+            var registry = AvaloniaPropertyRegistry.Instance;
             var parser = new PropertyParser();
             var reader = new Reader((string)value);
             var (ns, owner, propertyName) = parser.Parse(reader);
-            var ownerType = TryResolveOwnerByName(context, ns, owner) ??
-                context.GetFirstAmbientValue<ControlTemplate>()?.TargetType ??
-                context.GetFirstAmbientValue<Style>()?.Selector?.TargetType;
+            var ownerType = TryResolveOwnerByName(context, ns, owner);
+            var targetType = context.GetFirstAmbientValue<ControlTemplate>()?.TargetType ??
+                context.GetFirstAmbientValue<Style>()?.Selector?.TargetType ??
+                typeof(Control);
+            var effectiveOwner = ownerType ?? targetType;
+            var property = registry.FindRegistered(effectiveOwner, propertyName);
 
-            if (ownerType == null)
+            if (property == null)
             {
-                throw new XamlLoadException(
-                    $"Could not determine the owner type for property '{propertyName}'. " +
-                    "Please fully qualify the property name or specify a target type on " +
-                    "the containing template.");
+                throw new XamlLoadException($"Could not find property '{effectiveOwner.Name}.{propertyName}'.");
             }
 
-            var property = AvaloniaPropertyRegistry.Instance.FindRegistered(ownerType, propertyName);
-
-            if (property == null)
+            if (effectiveOwner != targetType &&
+                !property.IsAttached &&
+                !registry.IsRegistered(targetType, property))
             {
-                throw new XamlLoadException($"Could not find AvaloniaProperty '{ownerType.Name}.{propertyName}'.");
+                throw new XamlLoadException($"Property '{effectiveOwner.Name}.{propertyName}' is not registered on '{targetType}'.");
             }
 
             return property;
diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaPropertyRegistryTests.cs b/tests/Avalonia.Base.UnitTests/AvaloniaPropertyRegistryTests.cs
index 8b2e500d37..c34e26ac5c 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaPropertyRegistryTests.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaPropertyRegistryTests.cs
@@ -99,17 +99,6 @@ namespace Avalonia.Base.UnitTests
             Assert.Null(result);
         }
 
-        [Fact]
-        public void FindRegisteredAttached_Finds_Property()
-        {
-            var result = AvaloniaPropertyRegistry.Instance.FindRegisteredAttached(
-                typeof(Class1),
-                typeof(AttachedOwner),
-                "Attached");
-
-            Assert.Equal(AttachedOwner.AttachedProperty, result);
-        }
-
         private class Class1 : AvaloniaObject
         {
             public static readonly StyledProperty<string> FooProperty =
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Converters/AvaloniaPropertyConverterTest.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Converters/AvaloniaPropertyConverterTest.cs
index a028e246a4..f6f56231bc 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Converters/AvaloniaPropertyConverterTest.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Converters/AvaloniaPropertyConverterTest.cs
@@ -10,6 +10,7 @@ using Xunit;
 using System.ComponentModel;
 using Portable.Xaml;
 using Portable.Xaml.Markup;
+using Avalonia.Controls;
 
 namespace Avalonia.Markup.Xaml.UnitTests.Converters
 {
@@ -26,7 +27,8 @@ namespace Avalonia.Markup.Xaml.UnitTests.Converters
         public void ConvertFrom_Finds_Fully_Qualified_Property()
         {
             var target = new AvaloniaPropertyTypeConverter();
-            var context = CreateContext();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
             var result = target.ConvertFrom(context, null, "Class1.Foo");
 
             Assert.Equal(Class1.FooProperty, result);
@@ -47,7 +49,8 @@ namespace Avalonia.Markup.Xaml.UnitTests.Converters
         public void ConvertFrom_Finds_Attached_Property()
         {
             var target = new AvaloniaPropertyTypeConverter();
-            var context = CreateContext();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
             var result = target.ConvertFrom(context, null, "AttachedOwner.Attached");
 
             Assert.Equal(AttachedOwner.AttachedProperty, result);
@@ -57,12 +60,37 @@ namespace Avalonia.Markup.Xaml.UnitTests.Converters
         public void ConvertFrom_Finds_Attached_Property_With_Parentheses()
         {
             var target = new AvaloniaPropertyTypeConverter();
-            var context = CreateContext();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
             var result = target.ConvertFrom(context, null, "(AttachedOwner.Attached)");
 
             Assert.Equal(AttachedOwner.AttachedProperty, result);
         }
 
+        [Fact]
+        public void ConvertFrom_Throws_For_Nonexistent_Property()
+        {
+            var target = new AvaloniaPropertyTypeConverter();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
+
+            var ex = Assert.Throws<XamlLoadException>(() => target.ConvertFrom(context, null, "Nonexistent"));
+
+            Assert.Equal("Could not find property 'Class1.Nonexistent'.", ex.Message);
+        }
+
+        [Fact]
+        public void ConvertFrom_Throws_For_Nonexistent_Attached_Property()
+        {
+            var target = new AvaloniaPropertyTypeConverter();
+            var style = new Style(x => x.OfType<Class1>());
+            var context = CreateContext(style);
+
+            var ex = Assert.Throws<XamlLoadException>(() => target.ConvertFrom(context, null, "AttachedOwner.NonExistent"));
+
+            Assert.Equal("Could not find property 'AttachedOwner.NonExistent'.", ex.Message);
+        }
+
         private ITypeDescriptorContext CreateContext(Style style = null)
         {
             var tdMock = new Mock<ITypeDescriptorContext>();
@@ -126,4 +154,4 @@ namespace Avalonia.Markup.Xaml.UnitTests.Converters
                 AvaloniaProperty.RegisterAttached<AttachedOwner, Class1, string>("Attached");
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
index 4517aa6aa1..1d2f90d383 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
@@ -7,6 +7,7 @@ using Avalonia.Markup.Xaml.Styling;
 using Avalonia.Media;
 using Avalonia.Styling;
 using Avalonia.UnitTests;
+using Portable.Xaml;
 using Xunit;
 
 namespace Avalonia.Markup.Xaml.UnitTests.Xaml
@@ -172,5 +173,30 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
                 Assert.Equal(Dock.Right, DockPanel.GetDock(textBlock));
             }
         }
+
+        [Fact]
+        public void Disallows_Setting_Non_Registered_Property()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
+    <Window.Styles>
+        <Style Selector='TextBlock'>
+            <Setter Property='Button.IsDefault' Value='True'/>
+        </Style>
+    </Window.Styles>
+    <TextBlock/>
+</Window>";
+                var loader = new AvaloniaXamlLoader();
+                var ex = Assert.Throws<XamlObjectWriterException>(() => loader.Load(xaml));
+
+                Assert.Equal(
+                    "Property 'Button.IsDefault' is not registered on 'Avalonia.Controls.TextBlock'.",
+                    ex.InnerException.Message);
+            }
+        }
     }
 }

From 62526bef3599681e08d9b6a2ed51d8b9316f0165 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@users.noreply.github.com>
Date: Fri, 20 Jul 2018 21:38:14 +0200
Subject: [PATCH 5/6] Don't disallow setting unregistered properties.

The changes made to the animation system in #1768 currently needs to be able to set any property on any object in order for animations on transforms to work.
---
 .../Converters/AvaloniaPropertyTypeConverter.cs          | 9 ++++++++-
 tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs  | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
index 2470778685..0588e82901 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
@@ -5,6 +5,7 @@ using System;
 using System.ComponentModel;
 using System.Globalization;
 using Avalonia.Controls;
+using Avalonia.Logging;
 using Avalonia.Markup.Parsers;
 using Avalonia.Markup.Xaml.Parsers;
 using Avalonia.Markup.Xaml.Templates;
@@ -42,7 +43,13 @@ namespace Avalonia.Markup.Xaml.Converters
                 !property.IsAttached &&
                 !registry.IsRegistered(targetType, property))
             {
-                throw new XamlLoadException($"Property '{effectiveOwner.Name}.{propertyName}' is not registered on '{targetType}'.");
+                Logger.Warning(
+                    LogArea.Property,
+                    this,
+                    "Property '{Owner}.{Name}' is not registered on '{Type}'.",
+                    effectiveOwner,
+                    propertyName,
+                    targetType);
             }
 
             return property;
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
index 1d2f90d383..beaf7477d0 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/StyleTests.cs
@@ -174,7 +174,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
             }
         }
 
-        [Fact]
+        [Fact(Skip = "The animation system currently needs to be able to set any property on any object")]
         public void Disallows_Setting_Non_Registered_Property()
         {
             using (UnitTestApplication.Start(TestServices.StyledWindow))

From dc6f14e77550bbf898d48a93f92ac4f1b1fafb8c Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@users.noreply.github.com>
Date: Fri, 20 Jul 2018 23:04:28 +0200
Subject: [PATCH 6/6] Reader -> CharacterReader

And moved `CharacterReader` and `IdentifierParser` into Avalonia.Utilities.
---
 .../Utilities/CharacterReader.cs}             |  6 +--
 .../Utilities}/IdentifierParser.cs            |  4 +-
 .../AvaloniaPropertyTypeConverter.cs          |  3 +-
 .../Parsers/PropertyParser.cs                 |  3 +-
 .../Markup/Parsers/ArgumentListParser.cs      |  3 +-
 .../Parsers/ExpressionObserverBuilder.cs      |  3 +-
 .../Markup/Parsers/ExpressionParser.cs        | 23 +++++------
 .../Parsers/PropertyParserTests.cs            | 39 ++++++++++---------
 8 files changed, 45 insertions(+), 39 deletions(-)
 rename src/{Markup/Avalonia.Markup/Markup/Parsers/Reader.cs => Avalonia.Base/Utilities/CharacterReader.cs} (89%)
 rename src/{Markup/Avalonia.Markup/Markup/Parsers => Avalonia.Base/Utilities}/IdentifierParser.cs (94%)

diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs b/src/Avalonia.Base/Utilities/CharacterReader.cs
similarity index 89%
rename from src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs
rename to src/Avalonia.Base/Utilities/CharacterReader.cs
index 4a3d6aa277..0910d5b969 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/Reader.cs
+++ b/src/Avalonia.Base/Utilities/CharacterReader.cs
@@ -3,14 +3,14 @@
 
 using System;
 
-namespace Avalonia.Markup.Parsers
+namespace Avalonia.Utilities
 {
-    public class Reader
+    public class CharacterReader
     {
         private readonly string _s;
         private int _i;
 
-        public Reader(string s)
+        public CharacterReader(string s)
         {
             _s = s;
         }
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs b/src/Avalonia.Base/Utilities/IdentifierParser.cs
similarity index 94%
rename from src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs
rename to src/Avalonia.Base/Utilities/IdentifierParser.cs
index 9431dab45e..14b8affbdd 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/IdentifierParser.cs
+++ b/src/Avalonia.Base/Utilities/IdentifierParser.cs
@@ -4,11 +4,11 @@
 using System.Globalization;
 using System.Text;
 
-namespace Avalonia.Markup.Parsers
+namespace Avalonia.Utilities
 {
     public static class IdentifierParser
     {
-        public static string Parse(Reader r)
+        public static string Parse(CharacterReader r)
         {
             if (IsValidIdentifierStart(r.Peek))
             {
diff --git a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
index 0588e82901..627a646bcf 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Converters/AvaloniaPropertyTypeConverter.cs
@@ -10,6 +10,7 @@ using Avalonia.Markup.Parsers;
 using Avalonia.Markup.Xaml.Parsers;
 using Avalonia.Markup.Xaml.Templates;
 using Avalonia.Styling;
+using Avalonia.Utilities;
 using Portable.Xaml.ComponentModel;
 
 namespace Avalonia.Markup.Xaml.Converters
@@ -25,7 +26,7 @@ namespace Avalonia.Markup.Xaml.Converters
         {
             var registry = AvaloniaPropertyRegistry.Instance;
             var parser = new PropertyParser();
-            var reader = new Reader((string)value);
+            var reader = new CharacterReader((string)value);
             var (ns, owner, propertyName) = parser.Parse(reader);
             var ownerType = TryResolveOwnerByName(context, ns, owner);
             var targetType = context.GetFirstAmbientValue<ControlTemplate>()?.TargetType ??
diff --git a/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs b/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs
index ce82ffe0a1..702758efae 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Parsers/PropertyParser.cs
@@ -1,12 +1,13 @@
 using System;
 using Avalonia.Data.Core;
 using Avalonia.Markup.Parsers;
+using Avalonia.Utilities;
 
 namespace Avalonia.Markup.Xaml.Parsers
 {
     internal class PropertyParser
     {
-        public (string ns, string owner, string name) Parse(Reader r)
+        public (string ns, string owner, string name) Parse(CharacterReader r)
         {
             if (r.End)
             {
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/ArgumentListParser.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/ArgumentListParser.cs
index ae48657c01..89ef5dcabc 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/ArgumentListParser.cs
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/ArgumentListParser.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using Avalonia.Data.Core;
+using Avalonia.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -10,7 +11,7 @@ namespace Avalonia.Markup.Parsers
 {
     internal static class ArgumentListParser
     {
-        public static IList<string> Parse(Reader r, char open, char close)
+        public static IList<string> Parse(CharacterReader r, char open, char close)
         {
             if (r.Peek == open)
             {
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionObserverBuilder.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionObserverBuilder.cs
index ddbe252fc0..6cfb86634b 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionObserverBuilder.cs
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionObserverBuilder.cs
@@ -1,4 +1,5 @@
 using Avalonia.Data.Core;
+using Avalonia.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Reactive;
@@ -15,7 +16,7 @@ namespace Avalonia.Markup.Parsers
                 return new EmptyExpressionNode();
             }
 
-            var reader = new Reader(expression);
+            var reader = new CharacterReader(expression);
             var parser = new ExpressionParser(enableValidation, typeResolver);
             var node = parser.Parse(reader);
 
diff --git a/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionParser.cs b/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionParser.cs
index 95bb421777..682be572da 100644
--- a/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionParser.cs
+++ b/src/Markup/Avalonia.Markup/Markup/Parsers/ExpressionParser.cs
@@ -3,6 +3,7 @@
 
 using Avalonia.Data.Core;
 using Avalonia.Markup.Parsers.Nodes;
+using Avalonia.Utilities;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -20,7 +21,7 @@ namespace Avalonia.Markup.Parsers
             _enableValidation = enableValidation;
         }
 
-        public ExpressionNode Parse(Reader r)
+        public ExpressionNode Parse(CharacterReader r)
         {
             var nodes = new List<ExpressionNode>();
             var state = State.Start;
@@ -64,7 +65,7 @@ namespace Avalonia.Markup.Parsers
             return nodes.FirstOrDefault();
         }
 
-        private State ParseStart(Reader r, IList<ExpressionNode> nodes)
+        private State ParseStart(CharacterReader r, IList<ExpressionNode> nodes)
         {
             if (ParseNot(r))
             {
@@ -93,7 +94,7 @@ namespace Avalonia.Markup.Parsers
             return State.End;
         }
 
-        private static State ParseAfterMember(Reader r, IList<ExpressionNode> nodes)
+        private static State ParseAfterMember(CharacterReader r, IList<ExpressionNode> nodes)
         {
             if (ParseMemberAccessor(r))
             {
@@ -112,7 +113,7 @@ namespace Avalonia.Markup.Parsers
             return State.End;
         }
 
-        private State ParseBeforeMember(Reader r, IList<ExpressionNode> nodes)
+        private State ParseBeforeMember(CharacterReader r, IList<ExpressionNode> nodes)
         {
             if (ParseOpenBrace(r))
             {
@@ -132,7 +133,7 @@ namespace Avalonia.Markup.Parsers
             }
         }
 
-        private State ParseAttachedProperty(Reader r, List<ExpressionNode> nodes)
+        private State ParseAttachedProperty(CharacterReader r, List<ExpressionNode> nodes)
         {
             string ns = string.Empty;
             string owner;
@@ -171,7 +172,7 @@ namespace Avalonia.Markup.Parsers
             return State.AfterMember;
         }
 
-        private State ParseIndexer(Reader r, List<ExpressionNode> nodes)
+        private State ParseIndexer(CharacterReader r, List<ExpressionNode> nodes)
         {
             var args = ArgumentListParser.Parse(r, '[', ']');
 
@@ -184,27 +185,27 @@ namespace Avalonia.Markup.Parsers
             return State.AfterMember;
         }
         
-        private static bool ParseNot(Reader r)
+        private static bool ParseNot(CharacterReader r)
         {
             return !r.End && r.TakeIf('!');
         }
 
-        private static bool ParseMemberAccessor(Reader r)
+        private static bool ParseMemberAccessor(CharacterReader r)
         {
             return !r.End && r.TakeIf('.');
         }
 
-        private static bool ParseOpenBrace(Reader r)
+        private static bool ParseOpenBrace(CharacterReader r)
         {
             return !r.End && r.TakeIf('(');
         }
 
-        private static bool PeekOpenBracket(Reader r)
+        private static bool PeekOpenBracket(CharacterReader r)
         {
             return !r.End && r.Peek == '[';
         }
 
-        private static bool ParseStreamOperator(Reader r)
+        private static bool ParseStreamOperator(CharacterReader r)
         {
             return !r.End && r.TakeIf('^');
         }
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs
index a05485f55b..cae6449722 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Parsers/PropertyParserTests.cs
@@ -2,6 +2,7 @@
 using Avalonia.Data.Core;
 using Avalonia.Markup.Parsers;
 using Avalonia.Markup.Xaml.Parsers;
+using Avalonia.Utilities;
 using Xunit;
 
 namespace Avalonia.Markup.Xaml.UnitTests.Parsers
@@ -12,7 +13,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Parses_Name()
         {
             var target = new PropertyParser();
-            var reader = new Reader("Foo");
+            var reader = new CharacterReader("Foo");
             var (ns, owner, name) = target.Parse(reader);
 
             Assert.Null(ns);
@@ -24,7 +25,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Parses_Owner_And_Name()
         {
             var target = new PropertyParser();
-            var reader = new Reader("Foo.Bar");
+            var reader = new CharacterReader("Foo.Bar");
             var (ns, owner, name) = target.Parse(reader);
 
             Assert.Null(ns);
@@ -36,7 +37,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Parses_Namespace_Owner_And_Name()
         {
             var target = new PropertyParser();
-            var reader = new Reader("foo:Bar.Baz");
+            var reader = new CharacterReader("foo:Bar.Baz");
             var (ns, owner, name) = target.Parse(reader);
 
             Assert.Equal("foo", ns);
@@ -48,7 +49,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Parses_Owner_And_Name_With_Parentheses()
         {
             var target = new PropertyParser();
-            var reader = new Reader("(Foo.Bar)");
+            var reader = new CharacterReader("(Foo.Bar)");
             var (ns, owner, name) = target.Parse(reader);
 
             Assert.Null(ns);
@@ -60,7 +61,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Parses_Namespace_Owner_And_Name_With_Parentheses()
         {
             var target = new PropertyParser();
-            var reader = new Reader("(foo:Bar.Baz)");
+            var reader = new CharacterReader("(foo:Bar.Baz)");
             var (ns, owner, name) = target.Parse(reader);
 
             Assert.Equal("foo", ns);
@@ -72,7 +73,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Empty_String()
         {
             var target = new PropertyParser();
-            var reader = new Reader("");
+            var reader = new CharacterReader("");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(0, ex.Column);
@@ -83,7 +84,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Only_Whitespace()
         {
             var target = new PropertyParser();
-            var reader = new Reader("  ");
+            var reader = new CharacterReader("  ");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(0, ex.Column);
@@ -94,7 +95,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Leading_Whitespace()
         {
             var target = new PropertyParser();
-            var reader = new Reader(" Foo");
+            var reader = new CharacterReader(" Foo");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(0, ex.Column);
@@ -105,7 +106,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Trailing_Whitespace()
         {
             var target = new PropertyParser();
-            var reader = new Reader("Foo ");
+            var reader = new CharacterReader("Foo ");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(3, ex.Column);
@@ -116,7 +117,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Invalid_Property_Name()
         {
             var target = new PropertyParser();
-            var reader = new Reader("123");
+            var reader = new CharacterReader("123");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(0, ex.Column);
@@ -127,7 +128,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Trailing_Junk()
         {
             var target = new PropertyParser();
-            var reader = new Reader("Foo%");
+            var reader = new CharacterReader("Foo%");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(3, ex.Column);
@@ -138,7 +139,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Invalid_Property_Name_After_Owner()
         {
             var target = new PropertyParser();
-            var reader = new Reader("Foo.123");
+            var reader = new CharacterReader("Foo.123");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(4, ex.Column);
@@ -149,7 +150,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Whitespace_Between_Owner_And_Name()
         {
             var target = new PropertyParser();
-            var reader = new Reader("Foo. Bar");
+            var reader = new CharacterReader("Foo. Bar");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(4, ex.Column);
@@ -160,7 +161,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Too_Many_Segments()
         {
             var target = new PropertyParser();
-            var reader = new Reader("Foo.Bar.Baz");
+            var reader = new CharacterReader("Foo.Bar.Baz");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(8, ex.Column);
@@ -171,7 +172,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Too_Many_Namespaces()
         {
             var target = new PropertyParser();
-            var reader = new Reader("foo:bar:Baz");
+            var reader = new CharacterReader("foo:bar:Baz");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(8, ex.Column);
@@ -182,7 +183,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Parens_But_No_Owner()
         {
             var target = new PropertyParser();
-            var reader = new Reader("(Foo)");
+            var reader = new CharacterReader("(Foo)");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(1, ex.Column);
@@ -193,7 +194,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Parens_And_Namespace_But_No_Owner()
         {
             var target = new PropertyParser();
-            var reader = new Reader("(foo:Bar)");
+            var reader = new CharacterReader("(foo:Bar)");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(1, ex.Column);
@@ -204,7 +205,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Missing_Close_Parens()
         {
             var target = new PropertyParser();
-            var reader = new Reader("(Foo.Bar");
+            var reader = new CharacterReader("(Foo.Bar");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(8, ex.Column);
@@ -215,7 +216,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Parsers
         public void Fails_With_Unexpected_Close_Parens()
         {
             var target = new PropertyParser();
-            var reader = new Reader("Foo.Bar)");
+            var reader = new CharacterReader("Foo.Bar)");
 
             var ex = Assert.Throws<ExpressionParseException>(() => target.Parse(reader));
             Assert.Equal(7, ex.Column);