Avalonia

Commit Graph

Author	SHA1	Message	Date
Evan	082a03b7c4	Handle DataValidationError notifications returned by ConvertBack (#22171 ) * Handle DataValidationError notifications returned by ConvertBack A converter returning a BindingNotification with DataValidationError fell through to the target type converter, which replaced it with a cast error that stringified the notification. Publish the original error instead. * Add additional failing tests. There are more `BindingNotification` cases to handle. * Handle the other `BindingNotification` cases. --------- Co-authored-by: grokys <grokys@users.noreply.github.com>	6 days ago
Evan	fedb14ce85	Short-circuit a null-conditional operator after a cast (#22174 ) Follow-up to #22082, which added the short-circuit to the property accessor nodes. The cast nodes still called ValidateNonNullSource, so a cast reported "Value is null" before the following ?. could suppress it. Casting null now produces null, as in C#, leaving any error to the member access that follows.	1 week ago
Evan	8057428233	Allow casting to a nested type in a binding path (#22173 ) The binding path parser built type names with ParseIdentifier, which doesn't accept '+', so a cast like ((local:Outer+Nested)DataContext) stopped parsing at the '+' and then failed expecting a ')'. Parse type names with a variant that accepts '+'. Ordinary identifiers are unchanged.	1 week ago
Steven Kirk	31d6979377	Fix data validation errors not showing for OneWayToSource bindings (#22103 ) * Add failing tests for OneWayToSource validation (#8235) Data validation errors from validation attributes (e.g. [MaxLength]) and INotifyDataErrorInfo are not displayed when binding with Mode=OneWayToSource. Add tests covering both the DataAnnotations and INDEI cases when writing to the source. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013gwdaykrFyoMZFeVmWMydb * Publish data validation errors for OneWayToSource bindings (#8235) In OneWayToSource mode, BindingExpression.OnNodeValueChanged discarded any data validation error produced when writing the value to the source, so validation attributes and INotifyDataErrorInfo errors were never displayed. Publish (and clear) the error via UnchangedValue so that the error state reaches the target without pushing a value back to it, preserving the one-way-to-source semantics. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013gwdaykrFyoMZFeVmWMydb * Added passing test for #15378. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>	2 weeks ago
Steven Kirk	7527557ca0	Short-circuit the binding chain on a null-conditional operator (#22082 ) * Add failing test for issue described in #22069. https://github.com/AvaloniaUI/Avalonia/pull/22069#issuecomment-5442287978 * Add failing test for #18949. * Add failing tests for null conditional on attached property. * Short-circuit the binding chain on a null-conditional operator. The null-conditional operator in a binding path was only applied to the node it was attached to: a null source produced a null value which was then passed to the next node in the chain, which raised "Value is null.". C# instead short-circuits the remainder of the expression, so `a?.b.c` evaluates to null when `a` is null. Do the same for binding paths. When a null-conditional node has a null source it now sets its own value and that of all subsequent nodes to null, and the binding publishes null rather than an error. Publishing null rather than UnsetValue means TargetNullValue still applies. Attached properties in reflection bindings never honoured the operator at all: the grammar parses `?.(Foo.Bar)` and sets AttachedPropertyNameNode.AcceptsNull, but ExpressionNodeFactory discarded the flag and AvaloniaPropertyAccessorNode had no way to accept it. Pass it through. Compiled bindings were unaffected as they route attached properties through PropertyAccessorNode. Fixes #18949. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Atuuu4jtp14QXXoCzkp2A6 * Add TargetNullValue tests for short-circuited chains. Covers `A?.B.C` where A is null, for both CLR and Avalonia properties. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_014aahFHMmgxZtZ5EH3H5Xcc --------- Co-authored-by: Claude Opus 5 <noreply@anthropic.com>	3 weeks ago
Steven Kirk	15a9c99fc6	Add typed binding expressions (#21552 ) * Update ncrunch config. * Initial groundwork for typed binding expressions. - Moved a bunch of stuff from `UntypedBindingExpressionBase` to `BindingExpressionBase` - Make various APIs accept `BindingExpressionBase` instead of `UntypedBindingExpressionBase` - Added a typed `IPropertyInfo` - Added a method on the `CompiledBindingPathBuilder` to build typed property accessors - Initial basic implementation of `TypedBindingExpression` * Track values in typed binding expression. * Support binding mode in typed binding expression. * Add typed binding expression benchmarks. Add Setup/Values benchmarks comparing the typed binding expression against the untyped CompiledBinding (as emitted by the XAML compiler today) and the reflection-based Binding. Writing the benchmarks surfaced that TypedBindingExpression never detached: it had no Dispose override, so disposing a binding (or rebinding the same property) leaked its PropertyChanged subscriptions and left it registered in the value store. Wire up disposal mirroring UntypedBindingExpressionBase: stop, detach handlers, remove from the value store and frame. This required widening IBindingExpressionSink.OnCompleted from UntypedBindingExpressionBase to BindingExpressionBase. Also fix a nullable warning that broke the Release build. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> @ * Don't box value in IBindingExpressionSink.OnChanged. Instead notify the sink of what's changed and let the sink read the value boxed or unboxed. * Move `IValueEntry` to `BindingExpressionBase` * Fall back to BindingExpression. Make `TypedPropertyElement` derive from `PropertyElement` and fall back to creating a standard boxing `BindingExpression` if any of the requirements for a typed binding expression are not met. * Don't use typed expressions for DataContext. * Emit typed binding expression from XAML compiler. When a compiled binding path is shape-eligible (single CLR property on a reference-type source, no transforms, instance getter) the compiler now emits a call to the typed CompiledBindingPathBuilder.Property<TSource, TResult> overload, producing a TypedPropertyElement that the runtime turns into a non-boxing TypedBindingExpression<TSource, TValue>. Other shapes continue to use the existing untyped emission path, and runtime fallback to BindingExpression still kicks in when modifiers (Source, Converter, StringFormat, etc.) make the typed expression unsuitable. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * Add failing tests for TwoWay typed binding source echo. TypedBindingExpression writes the source value back to the source both on attach and whenever the source raises a change: pushing the value to the target re-enters OnTargetPropertyChanged, which (in TwoWay mode) calls WriteValueToSource with the value that just arrived from the source. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * Don't echo source value back to source in TwoWay typed binding. When TypedBindingExpression pushed the source value to the target, the resulting target PropertyChanged re-entered OnTargetPropertyChanged which, in TwoWay mode, wrote the value straight back to the source - a redundant round-trip on every attach and every source-originated change. Guard the source->target push with a flag and skip WriteValueToSource while it is set, so only genuine target changes are written back to the source. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * Address typed binding code-review follow-ups. - Reset _isRunning when a typed binding is unsubscribed so the expression can be restarted (and re-subscribe to its source) if the value store reactivates the entry later, matching UntypedBindingExpressionBase.Stop(). - Remove a stray `using static PropertySetSnapshot` import. - Extract the duplicated IValueEntry value-unwrapping logic (shared by EffectiveValue<T> and DirectPropertyBase) into IValueEntry.TryGetValue. - Drop the unreachable UpdateSourceTrigger NotSupportedException in CreateTypedExpression; CanUseTypedBindingExpression already constrains it. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * Fix TypedBinding_Values benchmark build error. The typed binding path was built with a single-argument `Property(propertyInfo)` call, which has no matching overload, so the benchmark project did not compile. Use the same typed three-argument overload as TypedBinding_Setup so the benchmark exercises the TypedPropertyElement path. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * Skip typed binding expression for data-validation properties. TypedBindingExpression does not support data validation, but the eligibility check didn't account for it, so a directly-assignable single-property DataContext binding to a validation-enabled target (e.g. TextBox.Text, NumericUpDown.Value) would take the typed path and silently drop validation errors. Fall back to the untyped BindingExpression when the target property enables data validation. Data validation support in the typed expression can be added as a follow-up. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * Clarify that data validation is not supported. * Address typed binding review comments. - React to null/empty PropertyChanged.PropertyName ("all properties changed") in the typed expression, matching the untyped path. - Swallow source getter exceptions raised during PropertyChanged. - Fall back to the untyped path for non-StyledElement targets, read-only sources and wider target types in TwoWay/OneWayToSource modes. - Fix a stray space in an exception message. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * Share TypedBindingExpression.Attach validation across instantiations. Factor the validation logic (most notably the exception string formatting) out of the generic Attach method into a non-generic static helper. It only uses typeof(TValue), not TValue, so sharing it avoids duplicating the code per generic instantiation, a meaningful NativeAOT size saving (~3.3 KB => ~2.5 KB per instantiation). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * Update API suppressions. These APIs are in a `[PrivateApi]`. * Use cached boolean boxes in typed binding expression. Merging main brought in the cached boxed booleans emitted for compiled binding property getters (#21065), but bindings that now take the typed binding expression path don't go through that getter: the value is boxed in TypedBindingExpression.GetUntypedValue when the target property isn't strongly typed (e.g. binding a bool to TextBlock.Tag). Box booleans via a shared cache there too, restoring the no-allocation-per-read behaviour. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QkxawATDHa6rbPaDmPCLHZ * Extract the whole TypedBindingExpression.Attach body into AttachCore. `3198196b4c` only factored out the validation, leaving the field assignments in the generic method. As MrJul pointed out, none of those assignments depend on TSource or TValue either, so the entire body can move into a method that doesn't reference the generic parameters and be shared across instantiations rather than duplicated per instantiation. Attach is now just a forwarder passing typeof(TValue) as a Type, and AttachCore reads _sink/TargetProperty directly instead of having them threaded through as parameters, which reads better than the previous split. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QkxawATDHa6rbPaDmPCLHZ * Move the method alongside the other privates. * Add failing tests for typed binding expression breaking changes. Each test binds the same property twice: once via a path which produces a TypedBindingExpression and once via a path which produces an untyped BindingExpression. The assertions describe the untyped behaviour, so the typed cases fail where the typed expression diverges: - A binding with no value (null or incompatible DataContext) publishes the target property's default value at the binding's priority instead of not contributing a value, overriding style setters and breaking inheritance. - Writing a value of another type, or null, to an object-typed target property throws from OnTargetPropertyChanged. - No binding error is logged when the DataContext is of the wrong type. - A throwing source getter leaves the stale value in place. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01B66teLaFQBr9GJe4a1aTZm * Fix typed binding expression divergences from the untyped path. - Don't notify when the expression has no value and had none before: doing so pushed the target property's default value at the binding's priority, overriding style setters and breaking property inheritance. - Read the target property's new value defensively. The binding value type only needs to be assignable to the target property type, so the property can hold a value which isn't a TValue; casting it threw out of the caller's SetValue. - Log a binding error when the DataContext can't be converted to the source type, and when the source getter throws. The getter also now clears the value rather than leaving the stale one in place. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01B66teLaFQBr9GJe4a1aTZm * Pass correct priority to child bindings. The priority here doesn't actually have any effect as the binding isn't in a value store, but there's no reason to not use the correct one. * Use the typed overload. * Set initial priority to default priority. Makes `TypedBindingExpressionBase` and `UntypedBindingExpressionBase` have the same behavior here. * Remove unused vars. * We now have a typed value here. * Publish typed binding values on the UI thread. The source's PropertyChanged event can be raised on any thread, so marshal the notification to the UI thread as UntypedBindingExpressionBase does. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01B1ZwmCJkThPSeViLnRxoYs * Share the property info cache lookup. Emit and EmitTyped had identical cache lookups, differing only in which dictionary they searched. Also delay constructing the generic types in EmitTyped until a cache miss, as they aren't needed on a hit. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01B1ZwmCJkThPSeViLnRxoYs * Share the property accessor delegate emission. EmitFunc was duplicated as a local function in both Emit and EmitTyped. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01B1ZwmCJkThPSeViLnRxoYs --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	3 weeks ago
Dong Bin	82dc3b56c1	Support {Binding ^} pattern for IObservable DataContext (#21812 ) Previously {Binding ^} was not parsed because ParseStart did not recognize the ^ stream operator. Also, {Binding .^} failed because ParseDot returned State.End immediately, preventing subsequent operators. Changes: - ParseStart: recognize ^, emit EmptyExpressionNode + StreamNode - ParseDot: return State.AfterMember instead of State.End, so .^ works - Add grammar tests for ^ and .^ patterns	2 months ago
Nathan Nguyen	c3a5c49699	fix(binding): reapply cached source values during UpdateTarget (#21756 ) * Added failing test for #21746. * fix(binding): reapply cached source values during UpdateTarget UpdateTarget did not restore an uncommitted explicit two-way target value when the source still matched the binding expression's cached value. Equal-value suppression then prevented ValueStore from receiving the refresh.\n\nTrack the synchronous UpdateTarget rebuild and force publication only for that path, so the source value is reapplied without changing normal binding notification deduplication. The preceding regression test covers the observable behavior in both reflection and compiled binding paths. --------- Co-authored-by: grokys <grokys@users.noreply.github.com>	2 months ago
Martim Claudino	17c88145ee	Fix #17674 : OneWay binding fails to update target after local change (#20964 ) * Fix #20816: OneWay binding fails to update target after local change When a OneWay binding target is modified locally (e.g., via user interaction on a ToggleButton), subsequent PropertyChanged events from the source were being ignored. This occurred because the binding expression incorrectly suppressed the update. This patch modifies UntypedBindingExpressionBase to ensure that OneWay bindings always propagate changes from the source to the target, overriding any previous local changes. Unit tests were also added to prevent future regressions on this behavior. Signed-off-by: Martim Claudino <martimffclaudino@tecnico.ulisboa.pt> * fix: scope forceUpdate to OneWay mode, use SetCurrentValue in tests and clean usings Signed-off-by: Martim Claudino <martimffclaudino@tecnico.ulisboa.pt> --------- Signed-off-by: Martim Claudino <martimffclaudino@tecnico.ulisboa.pt>	5 months ago
Evan	c62e1dffff	Fix TextBox validation error persisting when reverting to same valid value (#20780 ) * Fix TextBox validation error persisting when reverting to same valid value When a TwoWay binding with validation had an error and the user set the target back to the same value that was last successfully written to the source, WriteTargetValueToSource() would bail out early because the target value matched LeafNode.Value. This prevented WriteValueToSource() from being called, so the validation error was never cleared. Add an ErrorType check to the condition in WriteTargetValueToSource() so that the write-through still happens when there is a pending validation error, matching the pattern already used in WriteValueToSource() at line 310. Fixes #20534 https://claude.ai/code/session_01LTinLuE1bsNKaLPuDSNuuw * Add test for validation error clearing when reverting to same valid value Reproduces the scenario from #20534 where a TwoWay binding with a setter that throws on invalid values fails to clear the validation error when the target is set back to the same value that was last successfully written to the source. https://claude.ai/code/session_01LTinLuE1bsNKaLPuDSNuuw * Remove redundant checks in WriteTargetValueToSource()	7 months ago
Steven Kirk	d9a6ae517f	Hide binding plugins and disable Data Annotations validation by default (#20623 ) * Make binding plugin API internal. Making everything pluggable like has performance implications even if the plugins are never customized (which will be the 99% case). `IPropertyAccessor` is used in `CompiledBindingPathBuilder` so needs to be kept public for the moment. * Disable Data Annotations validation by default. It [conflicts with `CommunityToolkit.Mvvm`](https://github.com/AvaloniaUI/Avalonia/issues/8397) which is now the default MVVM framework, so require it to be enabled in the `AppBuilder`. * Update API supressions. * Add back missing using --------- Co-authored-by: Julien Lebosquain <julien@lebosquain.net>	7 months ago
Steven Kirk	70f3bef705	Add CompiledBinding.Create factory methods from LINQ expressions (#20443 ) * Reminder for future me. * Move compiled bindings to Avalonia base. * Update suppressions. * Tweaked `BindingExpressionVisitor`. And documented public (internal) API. * Fix ncrunch config. * Add comprehensive unit tests for BindingExpressionVisitor. Tests cover all supported features including property access, indexers, AvaloniaProperty access, logical NOT, stream bindings, and type operators. Also includes tests for unsupported operations that should throw exceptions. Discovered bug: IsAssignableFrom check at line 139 is backwards, causing upcasts to incorrectly throw and downcasts to be incorrectly ignored. Bug is documented with skipped tests showing expected behavior and passing tests documenting current broken behavior. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Fix backwards IsAssignableFrom check in BindingExpressionVisitor. Fixed the inheritance cast check which was inverted, causing: - Upcasts (derived→base) to incorrectly throw exceptions - Downcasts (base→derived) to be incorrectly ignored Changed line 139 from: node.Operand.Type.IsAssignableFrom(node.Type) to: node.Type.IsAssignableFrom(node.Operand.Type) This correctly identifies safe upcasts (which are ignored) vs unsafe downcasts (which throw exceptions). Updated tests to remove skip attributes and removed the temporary tests that documented the broken behavior. All 33 tests now pass. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Allow downcasts and all reference type casts in binding expressions. Changed the cast handling to allow both upcasts and downcasts for reference types. This makes casts actually useful in binding expressions while still rejecting value type conversions that would require actual conversion logic. The logic now checks: - Both types must be reference types (not value types) - One type must be assignable to/from the other (either direction) This allows practical scenarios like: - Upcasts: (BaseClass)derived - Downcasts: (DerivedClass)baseInstance - Casting through object: (TargetType)(object)source The binding system will gracefully handle any runtime type mismatches. Updated tests to verify downcasts are allowed and added test for casting through object pattern. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Add clarifying test for cast transparency in binding expressions. Added test showing that casts are transparent in property chains. For example, ((TestClass)x).Property produces just one node for the property access - the cast doesn't create additional nodes. This clarifies that empty nodes for (TestClass)x is correct behavior: - Empty nodes = bind to source directly - The cast is just a type annotation, transparent to the binding path Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Fix: Casts should create ReflectionTypeCastNode, not be transparent. Casts were incorrectly being treated as transparent (not creating nodes), but CompiledBindingPath uses TypeCastPathElement which creates FuncTransformNode. For consistency and correctness, BindingExpressionVisitor should also create cast nodes using ReflectionTypeCastNode. Changes: - Convert expressions now create ReflectionTypeCastNode - TypeAs expressions now create ReflectionTypeCastNode - Both upcasts and downcasts create nodes (runtime checks handle failures) Examples: - x => (TestClass)x → 1 node (cast) - x => ((TestClass)x).Prop → 2 nodes (cast + property) - x => x.Child as object → 2 nodes (property + cast) This matches the behavior of CompiledBindingPathBuilder.TypeCast<T>(). Updated all related tests to verify cast nodes are created. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Use compiled cast functions instead of reflection-based type checks. Changed from ReflectionTypeCastNode (which uses Type.IsInstanceOfType) to FuncTransformNode with a compiled cast function. This matches how CompiledBindingPath handles TypeCastPathElement and provides better performance by avoiding reflection. The CreateCastFunc method compiles an expression `(object? obj) => obj as T` which generates efficient IL similar to the 'is T' pattern used in TypeCastPathElement<T>, rather than using reflection-based type checks. Performance improvement: - Before: Type.IsInstanceOfType() reflection call for each cast - After: Compiled IL using 'as' operator (same as TypeCastPathElement<T>) Updated tests to expect FuncTransformNode instead of ReflectionTypeCastNode. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Reuse TypeCastPathElement<T> cast function directly. Instead of compiling our own cast expression, extract the Cast delegate directly from TypeCastPathElement<T>. This ensures we use the exact same code path as CompiledBindingPath, avoiding any potential behavioral differences and code duplication. Benefits: - Code reuse - single implementation of cast logic - Consistency - same behavior as CompiledBindingPathBuilder.TypeCast<T>() - No duplicate expression compilation logic Implementation uses reflection to create the closed generic type and extract the pre-compiled Cast delegate, which is still more efficient than reflection-based type checks at runtime. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Revert to lambda compilation approach for cast functions. Reverted from using TypeCastPathElement<T> back to compiling lambda expressions directly. The lambda approach is cleaner and more straightforward: Benefits of lambda compilation: - No Activator.CreateInstance call (avoids reflection for construction) - More direct - creates exactly what we need - No coupling to TypeCastPathElement internal implementation - Simpler code flow The compiled lambda generates the same efficient IL code (using 'as' operator) as TypeCastPathElement<T> does, just without the indirection. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Code cleanup: Fix XML docs and remove unused usings. - Changed CreateCastFunc XML docs to use <remarks> tag for better formatting - Removed unused 'using Avalonia.Data;' from tests - Removed redundant '#nullable enable' from tests Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Refactor BindingExpressionVisitor to use CompiledBindingPathBuilder. Changes BindingExpressionVisitor to use CompiledBindingPathBuilder instead of directly creating ExpressionNode instances, unifying the approach with compile-time XAML bindings. Adds new BuildPath() method that returns CompiledBindingPath, while maintaining backwards compatibility through the existing BuildNodes() wrapper method. Key changes: - Replace internal List<ExpressionNode> with CompiledBindingPathBuilder - Refactor all visitor methods to call builder methods - Add accessor factory methods and implementations for property access - Support AvaloniaProperty, CLR properties, arrays, indexers, streams, casts - Update tests to expect PropertyAccessorNode, StreamNode, ArrayIndexerNode Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Remove CompiledBindingPathFromExpressionBuilder in favor of BindingExpressionVisitor. Now that BindingExpressionVisitor has been refactored to use CompiledBindingPathBuilder and provides a BuildPath() method, the test-only CompiledBindingPathFromExpressionBuilder class is redundant and can be removed. Changes: - Replace CompiledBindingPathFromExpressionBuilder.Build() with BindingExpressionVisitor<TIn>.BuildPath() in BindingExpressionTests - Delete CompiledBindingPathFromExpressionBuilder.cs test file - All 122 tests in BindingExpressionTests.Compiled continue to pass Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Move test-only methods from production code to test extensions. Removes BindingExpression.Create and BindingExpressionVisitor.BuildNodes from production code since they were only used by unit tests. Changes: - Remove BindingExpression.Create<TIn, TOut> method - Remove BindingExpressionVisitor.BuildNodes method - Add BindingExpressionVisitorExtensions in Base.UnitTests - Add BindingExpressionExtensions in LeakTests - Add static helper methods in test classes to reduce noise Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Add public CompiledBinding.Create factory methods from LINQ expressions. Adds two static factory methods to create CompiledBinding instances from lambda expressions using BindingExpressionVisitor.BuildPath(): - Create<TIn, TOut>(expression, converter, mode) Creates binding without explicit source (uses DataContext) - Create<TIn, TOut>(source, expression, converter, mode) Creates binding with explicit source This provides a type-safe, ergonomic API for creating compiled bindings from code without string-based paths. Usage: var binding = CompiledBinding.Create(viewModel, vm => vm.Title); textBlock.Bind(TextBlock.TextProperty, binding); Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * Merge CompiledBinding.Create overloads and add all binding property parameters. Consolidates the two Create method overloads into a single method with source as an optional parameter. Adds optional parameters for all CompiledBinding properties (priority, converterCulture, converterParameter, fallbackValue, stringFormat, targetNullValue, updateSourceTrigger, delay) per PR feedback. Properties that default to AvaloniaProperty.UnsetValue (source, fallbackValue, targetNullValue) use null-coalescing to convert null parameter values. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com> * (Re-)update suppressions. * Add missing using. * Fix ncrunch build. * Remove file I committed by accident. * PR feedback. * Store static members outside generic class. Based on PR feedback. --------- Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>	7 months ago
Steven Kirk	1086d9b5b0	Move compiled bindings to Avalonia.Base. (#20439 ) * Reminder for future me. * Move compiled bindings to Avalonia base. * Update suppressions. * Update API suppressions --------- Co-authored-by: Julien Lebosquain <julien@lebosquain.net>	8 months ago
Steven Kirk	5d3a9c167a	Fix BindingExpression.LeafNode throwing when nodes list is empty (#20442 ) Make LeafNode property nullable and return null when the binding expression has no nodes (e.g., when using a constant source with a converter but no path). This fixes an ArgumentOutOfRangeException that occurred when accessing LeafNode or Description properties on such bindings. Fixes #20441 Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>	8 months ago
Youssef Victor	c9e210eb70	Update to xunit.v3 (#20331 ) * Update to xunit.v3 * Little more progress * More fixes * Keep VSTest supported * Adjust Nuke * Few fixes * Fix for xunit 2 * Fix GetData override * Adjust * Use MTP for xunit 2 * Fix test * Better fix * --no-progress * Few more fixes * no progress * Fix test * Better fix * TRX * Move to Directory.Build.props * Unify on MTP v2 * Update * Update to stable * 1.0.1 * 1.0.2 * Fix some warnings * Fix more warnings * Fix more warnings	8 months ago
Steven Kirk	f2fc8d02f4	Move `IBinding` to `BindingBase` and tidy up some binding APIs (#19589 ) * Update ncrunch config. * Tidy up reflection and multi-binding APIs: - Move `BindingBase` and `MultiBinding` into Avalonia.Base - `BindingBase` becomes a true base class for all bindings, and contains only the `Instance` method - Properties common between reflection and compiled bindings are moved into `StandardBindingBase` - `Binding` is moved to Avalonia.Base and renamed to `ReflectionBinding` - A compatibility shim for `Binding` remains in Avalonia.Markup - Remove `IBinding` and `IBinding2` - Remove `ITreeDataTemplate's usage of `InstancedBinding` - Remove `NativeMenuBarPresenter`s usage of `InstancedBinding` - Remove `InstancedBinding` as it is now unused This required an update to the DataGrid submodule: cell data validation has been temporarily removed as this used `InstancedBinding`. * `Instance()` => `CreateInstance()`. The use of "Instance" as a verb is quite unusual apparently ;) * Seal classes where appropriate. * Seal classes where appropriate. * Remove `StandardBindingBase`. Simply duplicate the members in reflection and compiled binding classes. * Delete deleted submodule directory. * Add missing attribute. Fixes compile error. * Fix reference to removed class. * Update suppressions.	8 months ago
Julien Lebosquain	c68111294f	Enable nullability in Base/Markup/Markup.Xaml unit tests (#20346 ) * Enable nullability in UnitTests * Enable nullability in Base.UnitTests * Enable nullability in Markup.UnitTests * Enable nullability in Markup.Xaml.UnitTests	9 months ago
Ondřej Sušovský	21a38e81c4	Fix validation error not being cleared on valid input (#19477 ) * Add failing test for binding error not being cleared, when bound value does not change * Fix clearing binding error	1 year ago
Julien Lebosquain	c3f02518e5	Fix binding null conditional operator not working with AvaloniaProperty (#18583 ) * Add failing tests for null conditional operator with AvaloniaPropery * Fix null conditional operator with AvaloniaProperty	1 year ago
Steven Kirk	fb5121a42f	Null conditional operator in bindings (#18270 ) * Update ncrunch config. * Fix test naming. * Add BindingExpressionGrammar tests. We only had tests for the error states, and that was named incorrectly. * Parse null-conditionals in bindings. * Initial impl of null conditionals in binding path. Fixes #17029. * Ensure that nothing is logged. * Make "?." work when binding to methods. * Don't add a new public API. And add a comment reminding us to make this class internal for 12.0. * Use existing method.	2 years ago
Julien Lebosquain	9d03a01afa	Made OneTime bindings update on DataContext changes (#17683 ) * Add failing tests for OneTime and null data context bindings * Made OneTime bindings update on DataContext changes Also allows null as a valid value for bindings without path * Remove now obsolete test	2 years ago
Julien Lebosquain	20f77a3490	Fix bindings without property path (#16729 ) * Added failing binding tests * Fix bindings without property path --------- Co-authored-by: Benedikt Stebner <Gillibald@users.noreply.github.com>	2 years ago
Steven Kirk	6b0f09a372	Make bindings react to PropertyChanged even if property hasn't changed (#16150 ) * Added failing test for #16137. * Raise node change even if value hasn't changed. Fixes #16137.	2 years ago
Steven Kirk	5e323b8fb1	Allow nested BindingNotifications. (#15722 ) * Added failing test for #15201. * Handle nested BindingNotifications. When #13970 was written, [a check](https://github.com/AvaloniaUI/Avalonia/pull/13970/files#diff-cfb25a491b9452e1815aa2c0d71465aaf81e99792a88a04a1a2ed572fd1930ffR60) was added to ensure that nested `BindingNotification`s didn't happen, and the refactor was written with the assumption that they wouldn't happen. The problem is that they _do_ happen: when a source object implements both `INotifyDataErrorInfo` and had data annotations, then the nested data validation plugins would each wrap the value coming from the previous plugin in a new `BindingNotification`, resulting in nested `BindingNotifications`. This adds support for nested binding notifications back in - even though IMO nesting binding notifications is a bug, if we're doing it and we previously supported it then we should continue to support it. Fixes #15201	2 years ago
Steven Kirk	8fe6e08020	Fixes spurious DataGrid data validation error (#15716 ) * Added failing tests for #15081. * Provide target property in BindingExpression ctor. Usually it is not necessary to provide the target property when creating a `BindingExpression` because the property will be assigned when the binding expression is attached to the target in `BindingExpressionBase.Attach`. This is however one case where `Attach` is not called: when the obsolete `binding.Initiate` method is called and then an observable is read from the `InstancedBinding` without the binding actually being attached to the target object. In this case, prior to the binding refactor in #13970 the value produced by the observable was still converted to the target type. After #13970, because the target property (and hence the target type) is not yet set, the conversion is to the target type is no longer done. `DataGrid` uses this obsolete method when editing cells, causing #15081. Ideally we'd fix that in `DataGrid` but I'm not happy making this change so close to 11.1, so instead fix this use-case to behave as before. Fixes #15081	2 years ago
Julien Lebosquain	cac27ddfc0	Misc warning fixes (#14766 ) * Fix XML doc warnings * Fix nullability warnings * Fix misc warnings	3 years ago
Steven Kirk	f6fe68eddb	Fix OneWayToSource bindings with read-only properties. (#14513 ) * Added more OneWayToSource tests. One of whom is failing. * Don't public value for OneWayToSource bindings. Looks to have been a brainfart. This allows `OneWayToSource` bindings to read-only properties.	3 years ago
Steven Kirk	3b1eb338e6	Binding System refactor (#13970 ) * Update ncrunch config. * WIP: Benchmarks * Initial refactor of binding infrastructure. - `ExpressionObserver` has been removed and its functionality merged with `BindingExpression` - `BindingExpression` handles all types of `BindingMode` itself; doesn't require `BindingOperations.Apply` to set up a separate observable for `TwoWay/`OneWayToSource` bindings - This allows us to fix some long-standing issues with `OneWayToSource` bindings - Expression nodes have been refactored - No longer split between `Avalonia.Base` and `Avalonia.Markup` - Categorize them according to whether they use reflection or not A few tests are failing around binding warnings: this is because the next step here is to fix binding warnings. * Make default binding Source = UnsetProperty. Null is a theoretically valid value for `Source`; setting it to null shouldn't mean "use the data context". * Move logging to BindingExpression. As `BindingExpression` now has enough information to decide when it's appropriate to log an error/warning or not. Fixes #5762 Fixes #9422 * Add compatibility hack for older compiled bindings. Previously, `CompiledBindingPathBuilder` didn't have a `TemplatedParent` method and instead the XAML compiler rewrite templated parent bindings to be a `$self.TemplateParent` property binding. resulting in extraneous logs. Add a constructor with an `apiVersion` to `CompiledBindingPathBuilder` which will be used by newer versions of the XAML compiler, and if a usage is detected using an `apiVersion` of 0, then upgrade `$self.TemplatedParent` to use a `TemplatedParentPathElement`. * Log errors from property accessors. * Don't log errors for named control bindings... ...on elements which aren't yet rooted. * Log errors for failed conversions. * Use consistent wording for binding warnings. "Could not convert" instead of "Cannot convert". * Log warnings for converter exceptions. * Don't convert new TargetTypeConverters each time. * Added failing test for implicit conversion. * Support cast operators in compiled bindings. A bit of a hack as we'd ideally not be using reflection when using compiled bindings. * This shouldn't be a public API. Should only be used for tests. * Make enum/int conversion work. * Check for SetValue equality after conversion. And also use "identity equals" where value types and strings use `object.Equals` and reference types use `object.ReferenceEquals`. * Added ConverterCulture back to bindings. * Fix merge error. Removed deleted files from csproj that were re-added due to indentation changes. * Use BindingExpression directly in ValueStoe. * Introduce BindingExpressionBase. And `UntypedBindingExpressionBase`. * Make TemplateBinding a BindingExpression. * Make DynamicResource use a BindingExpression. * WIP: Start exposing a BindingExpression API. * Finish exposing a BindingExpression API. * Fix OneTimeBinding. * Remove unneeded classes/methods. * Don't call obsolete API. * Make BindingExpressionBase the public API. This matches WPF's API. * Added BindingExpressionBase.UpdateTarget. * Initial implementation of UpdateSourceTrigger. * Don't use weak references for values. If they're boxed values, they can get collected. * No need for virtual/generic methods here now. * Reintroduce support for binding anchors. Turns out these were needed by animations, just our animation system has no unit tests so I missed that fact earlier. Add a basic animation unit test that fails without anchor support, and add binding anchors back in. Currently a private API as I suspect this feature shouldn't be needed outside the framework. * Include new property in clone. And add real-life example of `UpdateSourceTrigger=LostFocus` to BindingDemo. * Fix merge error. * Updated BindingExpression tests. - Make them run for both compiled and reflection bindings (found a bunch of tests that fail with compiled bindings) - Make them not depend on converting the `BindingExpression` to an observable and instead test the end result of the binding on an `AvaloniaObject` * Fix compiled binding indexer tests. * Use data validation plugins in PropertyAccessorNode. Added a warning suppression for now: we may need a separate `DataValidators` list for AOT-friendly plugins. * Don't separate plugins by reflection. `DataAnnotationsValidationPlugin` is public and so it can't be moved. No point in moving the others if this one will be in the wrong place. * Remove unneeded methods. * Make reflection binding tests use a string. Convert the `System.Linq.Expression` to a string and then use this, as reflection bindings will always be instanced with a string path. * Added TODO12 plan for IBinding2. * Use more specific exception. * Fix nits from code review. * Make expression nodes sealed where possible. * Unsubscribe on Stop, don't re-subscribe. D'oh. * Tweak ExpressionNode lists. Saves a few K in benchmarks and it's a cleaner API. * Add a pooled option in BindingExpressionGrammar. Micro-optimization. * Avoid allocations when enumerating binding plugins. * Add IBinding2 support to observable bind overloads. In the case of `TemplateBinding`, the `IObservable<object?>` bind overload is selected by C#. Add an explicit check for an `IBinding2` here to use the more performant code-path. * Remove disposed binding from ImmediateBindingFrame. * Added TemplateBinding benchmarks. * Remove duplicate items. Seems to have been caused by a merge error. * Fix exception when closing color picker. And add tests. * Don't skip converter when binding to self. * Don't pass UnsetValue to converters. This follows WPF behavior. * Log element name if present. More useful than just logging the control hash code. * Respect binding priority. * Throw on mismatched binding priorities. We don't want to respect the binding priority in this case as it breaks `TemplateBindings` when the default `LocalValue` priority is passed. Instead make sure that the priority parameter matches that of the expression. This reverts commit `a72765d705`. * Convert to target type in TemplateBinding. * Short-circuit target type conversion for same types.	3 years ago
Julien Lebosquain	e6c1670421	Fix unit tests culture (#13016 )	3 years ago
Steven Kirk	8948aa7e52	Added ConverterCulture to bindings. (#12876 ) Similar to WPF's `Binding.ConverterCulture` property.	3 years ago
Tom Edwards	796722f319	Never convert null to UnsetValue in bindings Revert ToggleButton.IsChecked hack	4 years ago
Max Katz	a78b0edd42	Changes after review	4 years ago
Simon Cropp	dba476c11c	fix more typos	4 years ago
Max Katz	59d7874b1d	Replace System.Reactive with internal extensions	4 years ago
Steven Kirk	b5891a2ead	Fix bug in ExpressionObserver. Ensure `rootGetter` is evaluated each time the observer is initialized; plus failing and now passing test.	4 years ago
Giuseppe Lippolis	de4b55f8ee	feat(tests): Address rule CA1822	4 years ago
Steven Kirk	fb0da85ad3	Merge core libraries. (#5831 ) * Merge core libraries. Everything below `Avalonia.Controls` into `Avalonia.Base`. * Move new files to correct place. * Removed unused dirs/projects, * Removed outdated references from theme assemblies. * Merge unit tests to match new assembly layout. * Fixup test namespaces. * Make directory match namespace. * Move files to match namespace. * Move files to match namespace. * Fix up incorrect namespace. `Avalonia.Visuals.Media.Imaging` -> `Avalonia.Media.Imaging`. * Fix resource URL. * Removed outdated dependencies. * Added missing project reference. * Update test namespaces. * Fix merge error. * Fix merge errors. * Fix bad merge in WindowsInteropTest.csproj. * Fix up merge errors in csprojs. * Remove merged tests from nuke. * Fix up namespace. * Fix compile error. * Fix failing tests. Now that more unit tests are present in Avalonia.Base.UnitTests, general `AvaloniaObject` properties are getting registered. Ignore those. Co-authored-by: Jumar Macato <16554748+jmacato@users.noreply.github.com>	4 years ago
Nikita Tsukanov	f010322a06	Force compacting WeakEvent subscriber list in before assertions in tests	5 years ago
Giuseppe Lippolis	c98918bc2a	Update tests	6 years ago
Dariusz Komosiński	00dbf12cee	Remove not needed code.	6 years ago
Dariusz Komosiński	8555fed86b	Add failing tests for #4733 and fix property accessor.	6 years ago
Kieran Devlin	f3e0863f52	Updated exception type for validation exceptions so that DataValidationErrors can extract the user friendly message.	6 years ago
Dariusz Komosinski	178a1aeb19	Add failing unit test.	6 years ago
Dariusz Komosinski	3b7d8574e8	Try matching for INPC before matching methods.	6 years ago
Steven Kirk	4d01dacd77	Remove copyright headers. Some of our files had them, some didn't. They serve no purpose legally so best to remove the ceremony.	7 years ago
José Pedro	1ba4c68a35	Implemented TargetNullValue for bindings.	7 years ago
Steven Kirk	6be3acb46c	Make ValueStore typed. Major refactor of the Avalonia core to make the styled property store typed.	7 years ago
all.owing	6dbe617ed6	One more tests fix	7 years ago
Dariusz Komosinski	868b5ea840	Update WeakReference usages to use the generic one.	7 years ago
Nikita Tsukanov	048660ed8b	Implemented PropertyPathGrammar	7 years ago

1 2

72 Commits (fixes/macos-owned-window-level-inheritance)