FIX N-O

com.unity.uiwidgets/Runtime/widgets/navigation_toolbar.cs

 
 namespace Unity.UIWidgets.widgets {
     public class NavigationToolbar : StatelessWidget {
-        public NavigationToolbar(Key key = null, Widget leading = null, Widget middle = null,
-            Widget trailing = null, bool centerMiddle = true, float middleSpacing = kMiddleSpacing) : base(key) {
+        public NavigationToolbar(
+            Key key = null,
+            Widget leading = null, 
+            Widget middle = null,
+            Widget trailing = null, 
+            bool centerMiddle = true, 
+            float middleSpacing = kMiddleSpacing
+            ) : base(key) {
             this.leading = leading;
             this.middle = middle;
             this.trailing = trailing;
 
     class _ToolbarLayout : MultiChildLayoutDelegate {
         public _ToolbarLayout(
-            bool? centerMiddle = true,
+            bool? centerMiddle = null,
             float? middleSpacing = null,
             TextDirection? textDirection = null
         ) {
-            this.middleSpacing = middleSpacing ?? 0.0f;
+            this.middleSpacing = middleSpacing  ?? 0.0f;
             this.textDirection = textDirection ?? TextDirection.ltr;
         }
 
                 float middleStartMargin = leadingWidth + middleSpacing;
                 float middleStart = middleStartMargin;
                 float middleY = (size.height - middleSize.height) / 2.0f;
-                // If the centered middle will not fit between the leading and trailing
-                // widgets, then align its left or right edge with the adjacent boundary.
+                
                 if (centerMiddle) {
                     middleStart = (size.width - middleSize.width) / 2.0f;
                     if (middleStart + middleSize.width > size.width - trailingWidth) {

com.unity.uiwidgets/Runtime/widgets/nested_scroll_view.cs

                             reverse: widget.reverse,
                             physics: widget.physics != null
                                 ? widget.physics.applyTo(new ClampingScrollPhysics())
-                                : new ClampingScrollPhysics(),
-                            controller: _coordinator._outerController,
-                            slivers: widget._buildSlivers(
-                                _context, _coordinator._innerController, _lastHasScrolledBody
-                            ),
-                            handle: _absorberHandle
-                        );
+                            : new ClampingScrollPhysics(),
+                        controller: _coordinator._outerController,
+                        slivers: widget._buildSlivers(
+                            context,
+                            _coordinator._innerController,
+                            _lastHasScrolledBody
+                        ),
+                        handle: _absorberHandle
+                            );
                     }
                 )
             );
     class _NestedScrollViewCustomScrollView : CustomScrollView {
         public _NestedScrollViewCustomScrollView(
-            Axis scrollDirection,
-            bool reverse,
+            Axis scrollDirection, 
+            bool reverse ,
             ScrollPhysics physics,
             ScrollController controller,
             List<Widget> slivers,
                 if (!_outerController.hasClients) {
                     return null;
                 }
-
                 return _outerController.nestedPositions.Single();
             }
         }
         ScrollDirection _userScrollDirection = ScrollDirection.idle;
 
         public void updateUserScrollDirection(ScrollDirection value) {
+            D.assert(value != null);
             if (userScrollDirection == value) {
                 return;
             }
         }
 
         public void goBallistic(float velocity) {
-            beginActivity(createOuterBallisticScrollActivity(velocity),
+            beginActivity(
+                createOuterBallisticScrollActivity(velocity),
                 (_NestedScrollPosition position) => createInnerBallisticScrollActivity(position, velocity)
             );
         }
             _outerPosition.updateCanDrag(maxInnerExtent);
         }
 
-        public Future animateTo(float to,
-            TimeSpan duration,
-            Curve curve
+        public Future animateTo(
+            float to,
+            TimeSpan? duration = null,
+            Curve curve = null
-                duration,
+                duration ?? new TimeSpan(0,0,0,0),
                 curve
             );
             List<Future> resultFutures = new List<Future> {outerActivity.done};
                     DrivenScrollActivity innerActivity = position.createDrivenScrollActivity(
                         nestOffset(to, position),
-                        duration,
+                        duration ?? new TimeSpan(0,0,0,0),
                         curve
                     );
                     resultFutures.Add(innerActivity.done);
         }
 
         public override string ToString() {
-            return "$GetType()(outer=$_outerController; inner=$_innerController)";
+            return $"{GetType()}(outer={_outerController}; inner={_innerController})";
         }
     }
 

com.unity.uiwidgets/Runtime/widgets/overlay.cs

 
 namespace Unity.UIWidgets.widgets {
     public class OverlayEntry {
-        public OverlayEntry(WidgetBuilder builder = null, bool opaque = false, bool maintainState = false) {
+        public OverlayEntry(
+            WidgetBuilder builder = null, 
+            bool opaque = false, 
+            bool maintainState = false) {
             D.assert(builder != null);
             _opaque = opaque;
             _maintainState = maintainState;
 
                 _maintainState = value;
                 D.assert(_overlay != null);
-                _overlay._didChangeEntryOpacity();
+                _overlay?._didChangeEntryOpacity();
             }
         }
 
     }
 
     class _OverlayEntryWidgetState : State<_OverlayEntryWidget> {
-        public override Widget build(BuildContext context) {
+        public override Widget build(
+            BuildContext context) {
             return new TickerMode(
                 enabled: widget.tickerEnabled,
                 child: widget.entry.builder(context)
 
     class _RenderTheatre : ContainerRenderObjectMixinRenderBox<RenderBox, StackParentData> {
         internal _RenderTheatre(
-            TextDirection textDirection,
+            TextDirection textDirection ,
             List<RenderBox> children = null,
             int skipCount = 0
         ) {
             if (_resolvedAlignment != null) {
                 return;
             }
-            //FIXME: wait for changes on painting/alignment.cs (by Siyao)
-            //then uncomment the line below and remove the switch clauses
-            //_resolvedAlignment = AlignmentDirectional.topStart.resolve(textDirection);
-            switch (textDirection) {
-                case TextDirection.rtl:
-                    _resolvedAlignment = new Alignment(-1, -1);
-                    break;
-                case TextDirection.ltr:
-                    _resolvedAlignment = new Alignment(1, -1);
-                    break;
-            }
+            _resolvedAlignment = AlignmentDirectional.topStart.resolve(textDirection);
         }
 
         void _markNeedResolution() {