more fixes

com.unity.uiwidgets/Runtime/animation/tween_sequence.cs

 
         public TweenSequenceItem(
             Animatable<T> tween = null,
-            float weight = 0.0f
+            float? weight = 0.0f
-            this.tween = tween;
-            this.weight = weight;
+            this.tween = tween;
+            this.weight = weight.Value;
         }
 
         public readonly Animatable<T> tween;

com.unity.uiwidgets/Runtime/async/stopwatch.cs

 
 namespace Unity.UIWidgets.core {
    public  class Stopwatch {
-        static int _frequency;
+        static int? _frequency;
 
         // The _start and _stop fields capture the time when [start] and [stop]
         // are called respectively.
             if (_frequency == null) _initTicker();
         }
 
-        public int frequency {
+        public int? frequency {
             get { return _frequency; }
         }
 

com.unity.uiwidgets/Runtime/cupertino/activity_indicator.cs

     public class CupertinoActivityIndicator : StatefulWidget {
         public CupertinoActivityIndicator(
             Key key = null,
-            bool animating = true,
-            float radius = CupertinoActivityIndicatorUtils._kDefaultIndicatorRadius
+            bool? animating = true,
+            float? radius = CupertinoActivityIndicatorUtils._kDefaultIndicatorRadius
-            this.animating = animating;
-            this.radius = radius;
+            this.animating = animating.Value;
+            this.radius = radius.Value;
         }
 
         public readonly bool animating;

com.unity.uiwidgets/Runtime/cupertino/interface_level.cs

        
         public CupertinoUserInterfaceLevel(
             Key key = null,
-            CupertinoUserInterfaceLevelData data = default,
+            CupertinoUserInterfaceLevelData? data = null,
-            _data = data;
+            _data = data.Value;
         }
         public CupertinoUserInterfaceLevelData _data;
 

com.unity.uiwidgets/Runtime/cupertino/nav_bar.cs

 
     class _PersistentNavigationBar : StatelessWidget {
         public readonly _NavigationBarStaticComponents components;
-        public readonly bool middleVisible;
+        public readonly bool? middleVisible;
         public readonly EdgeInsetsDirectional padding;
 
         public _PersistentNavigationBar(
         ) : base(key: key) {
             this.components = components;
             this.padding = padding;
-            this.middleVisible = middleVisible ?? true;
+            this.middleVisible = middleVisible;
         }
 
         public override Widget build(BuildContext context) {
                 middle = middleVisible == null
                     ? middle
                     : new AnimatedOpacity(
-                        opacity: middleVisible ? 1.0f : 0.0f,
+                        opacity: middleVisible.Value ? 1.0f : 0.0f,
                         duration: NavBarUtils._kNavBarTitleFadeDuration,
                         child: middle
                     );

com.unity.uiwidgets/Runtime/cupertino/refresh.cs

    public class CupertinoSliverRefreshControl : StatefulWidget { 
        public CupertinoSliverRefreshControl(
            Key key = null,
-           float refreshTriggerPullDistance = _defaultRefreshTriggerPullDistance, 
-           float refreshIndicatorExtent = _defaultRefreshIndicatorExtent, 
+           float? refreshTriggerPullDistance = _defaultRefreshTriggerPullDistance, 
+           float? refreshIndicatorExtent = _defaultRefreshIndicatorExtent, 
            RefreshControlIndicatorBuilder  builder = null,
            RefreshCallback  onRefresh = null
            ) : base(key: key) {
                       "The refresh indicator cannot take more space in its final state " +
                       "than the amount initially created by overscrolling."
               );
-              this.refreshIndicatorExtent = refreshIndicatorExtent;
-              this.refreshTriggerPullDistance = refreshTriggerPullDistance;
+              this.refreshIndicatorExtent = refreshIndicatorExtent.Value;
+              this.refreshTriggerPullDistance = refreshTriggerPullDistance.Value;
               this.builder = builder ?? buildSimpleRefreshIndicator;
               this.onRefresh = onRefresh;
               
                   }
                   return RefreshIndicatorMode.armed;
                 }
-               
-                break;
+              
               case RefreshIndicatorMode.armed:
                 if (refreshState == RefreshIndicatorMode.armed && refreshTask == null) {
                   goToDone();

com.unity.uiwidgets/Runtime/cupertino/route.cs

         public static Future<T> showCupertinoDialog<T>(
             BuildContext context = null,
             WidgetBuilder builder =null,
-            bool useRootNavigator = true,
+            bool? useRootNavigator = true,
             RouteSettings routeSettings = null
         ) {
             D.assert(builder != null);
                 return builder(context1);
             },
             transitionBuilder: _buildCupertinoDialogTransitions,
-            useRootNavigator: useRootNavigator,
+            useRootNavigator: useRootNavigator.Value,
             routeSettings: routeSettings
                 );
         }
                 ImageFilter filter = null,
-            bool useRootNavigator = true,
-            bool? semanticsDismissible =null
+            bool? useRootNavigator = true
-            return Navigator.of(context, rootNavigator: useRootNavigator).push(
+            return Navigator.of(context, rootNavigator: useRootNavigator.Value).push(
                new _CupertinoModalPopupRoute(
                     barrierColor: CupertinoDynamicColor.resolve(_kModalBarrierColor, context),
                     barrierLabel: "Dismiss",

com.unity.uiwidgets/Runtime/cupertino/switch.cs

         public bool value {
             get { return _value; }
             set {
-                D.assert(value != null);
-                //markNeedsSemanticsUpdate();
             }
         }
 

com.unity.uiwidgets/Runtime/cupertino/tab_scaffold.cs

 using System.Collections.Generic;
-using System.Linq;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
 namespace Unity.UIWidgets.cupertino {
     public class CupertinoTabController : ChangeNotifier {
 
-        public CupertinoTabController(int initialIndex = 0) {
+        public CupertinoTabController(int? initialIndex = 0) {
-            _index = initialIndex;
+            _index = initialIndex.Value;
         }
 
         public bool _isDisposed = false;
             set {
-                D.assert(value != null);
                 D.assert(value >= 0);
                 if (_index == value) {
                     return;
             D.assert(
                 controller == null || controller.index < tabBar.items.Count, () =>
                     $"The CupertinoTabController's current index {controller.index} is " +
-                    $"out of bounds for the tab bar with {tabBar.items.Count} tabs"
+                    $"out2 of bounds for the tab bar with {tabBar.items.Count} tabs"
             );
             this.tabBar = tabBar;
             this.controller = controller;

com.unity.uiwidgets/Runtime/cupertino/text_selection.cs

                 );
             case TextSelectionHandleType.collapsed:
                 return new SizedBox();
-         }
-            D.assert(type != null);
-            return null;
+          }
+          return null;
         }
         public override Offset getHandleAnchor(TextSelectionHandleType type, float textLineHeight) {
             Size handleSize = getHandleSize(textLineHeight);

com.unity.uiwidgets/Runtime/cupertino/theme.cs

         public _CupertinoTextThemeDefaults textThemeDefaults;
 
         public _CupertinoThemeDefaults resolveFrom(BuildContext context, bool resolveTextTheme,  bool nullOk = false) {
-            D.assert(nullOk != null);
             Color convertColor(Color color) => CupertinoDynamicColor.resolve(color, context, nullOk: nullOk);
 
             return new _CupertinoThemeDefaults(

com.unity.uiwidgets/Runtime/gestures/force_press.cs

-using System.Collections.Generic;
-using System.Linq;
-using Unity.UIWidgets.scheduler;
 using Unity.UIWidgets.ui;
 
 namespace Unity.UIWidgets.gestures {
             Offset localPosition = null
         ) {
             D.assert(globalPosition != null);
-            D.assert(pressure != null);
-            localPosition = localPosition ?? globalPosition;
+            this.localPosition = localPosition ?? globalPosition;
             this.globalPosition = globalPosition;
             this.pressure = pressure;
         }

com.unity.uiwidgets/Runtime/gestures/tap.cs

 
         public readonly Offset localPosition;
 
-        public readonly PointerDeviceKind kind;
+        public readonly PointerDeviceKind? kind;
 
         public readonly int device;
     }

com.unity.uiwidgets/Runtime/material/app_bar.cs

             if (centerTitle != null) {
                 return centerTitle;
             }
-
-            D.assert(theme.platform != null);
-
             switch (theme.platform) {
                 case RuntimePlatform.Android:
                 case RuntimePlatform.LinuxEditor:

com.unity.uiwidgets/Runtime/material/dialog.cs

 
         public override Widget build(BuildContext context) {
             return new InkWell(
-                onTap: () => onPressed(),
+                onTap: () => onPressed?.Invoke(),
                 child: new Padding(
                     padding: padding ?? EdgeInsets.symmetric(vertical: 8.0f, horizontal: 24.0f),
                     child: child

com.unity.uiwidgets/Runtime/material/pickers/calendar_date_picker.cs

 using com.unity.uiwidgets.Runtime.rendering;
 using Unity.UIWidgets.animation;
 using Unity.UIWidgets.foundation;
-using Unity.UIWidgets.material;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
 using Unity.UIWidgets.ui;

com.unity.uiwidgets/Runtime/material/theme_data.cs

 
         public static readonly float maximumDensity = 4.0f;
 
-        public static readonly VisualDensity standard = new VisualDensity(0.0f, 0.0f);
+        public static readonly VisualDensity standard = new VisualDensity();
 
         public static readonly VisualDensity comfortable = new VisualDensity(horizontal: -1.0f, vertical: -1.0f);
 

com.unity.uiwidgets/Runtime/painting/basic_types.cs

             return null;
         }
         public static AxisDirection? textDirectionToAxisDirection(TextDirection textDirection) {
-            D.assert(textDirection != null);
             switch (textDirection) {
                 case TextDirection.rtl:
                     return AxisDirection.left;
             return null;
         }
         public static AxisDirection? flipAxisDirection(AxisDirection axisDirection) {
-            D.assert(axisDirection != null);
             switch (axisDirection) {
                 case AxisDirection.up:
                     return AxisDirection.down;
             throw new Exception("unknown axis");
         }
 
-        public static Axis axisDirectionToAxis(AxisDirection axisDirection) {
+        public static Axis? axisDirectionToAxis(AxisDirection? axisDirection) {
+            D.assert(axisDirection != null);
             switch (axisDirection) {
                 case AxisDirection.up:
                 case AxisDirection.down:
                     return Axis.horizontal;
             }
 
-            throw new Exception("unknown axisDirection");
+            return null;
-        public static AxisDirection textDirectionToAxisDirection(TextDirection textDirection) {
+        public static AxisDirection? textDirectionToAxisDirection(TextDirection textDirection) {
             switch (textDirection) {
                 case TextDirection.rtl:
                     return AxisDirection.left;
 
-            throw new Exception("unknown textDirection");
+            return null;
-        public static AxisDirection flipAxisDirection(AxisDirection axisDirection) {
-            switch (axisDirection) {
+        public static AxisDirection? flipAxisDirection(AxisDirection? axisDirection) {
+            D.assert(axisDirection != null);
+            switch (axisDirection.Value) {
                 case AxisDirection.up:
                     return AxisDirection.down;
                 case AxisDirection.right:
                     return AxisDirection.right;
             }
 
-            throw new Exception("unknown axisDirection");
+            return null;
-        public static bool axisDirectionIsReversed(AxisDirection axisDirection) {
+        public static bool axisDirectionIsReversed(AxisDirection? axisDirection) {
+            D.assert(axisDirection != null);
             switch (axisDirection) {
                 case AxisDirection.up:
                 case AxisDirection.left:

com.unity.uiwidgets/Runtime/painting/decoration_image.cs

                 D.assert(() => {
                     // We check this first so that the assert will fire immediately, not just
                     // when the image is ready.
-                    if (configuration.textDirection == null) {
+                    if (configuration?.textDirection == null) {
                         throw new UIWidgetsError(new List<DiagnosticsNode>() {
                             new ErrorSummary(
                                 "DecorationImage.matchTextDirection can only be used when a TextDirection is available."),

com.unity.uiwidgets/Runtime/painting/edge_insets.cs

             if (a is EdgeInsets && b is EdgeInsets)
                 return EdgeInsets.lerp((EdgeInsets) a, (EdgeInsets) b, t);
             if (a is EdgeInsetsDirectional && b is EdgeInsetsDirectional)
-                return EdgeInsetsDirectional.lerp(a, b, t);
+                return EdgeInsetsDirectional.lerp((EdgeInsetsDirectional)a, (EdgeInsetsDirectional)b, t);
 
             return _MixedEdgeInsets.fromLRSETB(
                 MathUtils.lerpNullableFloat(a._left, b._left, t),
             get { return top + bottom; }
         }
 
-        public float along(Axis axis) {
+        public float along(Axis? axis) {
+            D.assert(axis != null);
             switch (axis) {
                 case Axis.horizontal:
                     return horizontal;
-
             throw new Exception("unknown axis");
         }
 

com.unity.uiwidgets/Runtime/painting/image_cache.cs

                     throw;
                 }
             }
-
-            bool listenedOnce = false;
+            
             _PendingImage untrackedPendingImage = null;
 
             void listener(ImageInfo info, bool syncCall) {
                 if (untrackedPendingImage == null) {
                     _touch(key, cachedImage);
                 }
-
-                listenedOnce = true;
             }
 
             ImageStreamListener streamListener = new ImageStreamListener(listener);

com.unity.uiwidgets/Runtime/painting/image_provider.cs

     public class NetworkImageLoadException : Exception {
         NetworkImageLoadException(int statusCode, Uri uri) {
             D.assert(uri != null);
-            D.assert(statusCode != null);
             this.statusCode = statusCode;
             this.uri = uri;
             _message = $"HTTP request failed, statusCode: {statusCode}, {uri}";

com.unity.uiwidgets/Runtime/painting/image_resolution.cs

         string _findNearest(SplayTree<float, string> candidates, float value) {
             if (candidates.ContainsKey(value))
                 return candidates[value];
-            float lower = candidates.lastKeyBefore(value);
-            float upper = candidates.firstKeyAfter(value);
-            if (lower == null)
-                return candidates[upper];
-            if (upper == null)
-                return candidates[lower];
+            var lower = candidates.lastKeyBefore(value);
+            var upper = candidates.firstKeyAfter(value);
-            else
-                return candidates[lower];
+            
+            return candidates[lower];
         }
 
         internal static readonly Regex _extractRatioRegExp = new Regex(@"/?(\d+(\.\d*)?)x$");

com.unity.uiwidgets/Runtime/painting/inline_span.cs

     public class InlineSpanSemanticsInformation : IEquatable<InlineSpanSemanticsInformation> {
         public InlineSpanSemanticsInformation(
             string text,
-            bool isPlaceholder = false,
+            bool? isPlaceholder = false,
             string semanticsLabel = null,
             GestureRecognizer recognizer = null
         ) {
-            requiresOwnNode = isPlaceholder || recognizer != null;
+            requiresOwnNode = isPlaceholder.Value || recognizer != null;
         }
 
         public static readonly InlineSpanSemanticsInformation placeholder =

com.unity.uiwidgets/Runtime/painting/text_painter.cs

             return value == 0x200F || value == 0x200E;
         }
         
-         public int getOffsetAfter(int offset) {
+         public int? getOffsetAfter(int offset) {
-                return 0;
+                return null;
-         public int getOffsetBefore(int offset) {
+         public int? getOffsetBefore(int offset) {
-                 return 0;
+                 return null;
              // TODO(goderbauer): doesn't handle extended grapheme clusters with more than one Unicode scalar value (https://github.com/flutter/flutter/issues/13404).
              return _isUtf16Surrogate(prevCodeUnit.Value) ? offset - 2 : offset - 1;
          }

com.unity.uiwidgets/Runtime/rendering/editable.cs

                 return _textPainter.textWidthBasis;
             }
             set {
-                D.assert(value != null);
                 if (_textPainter.textWidthBasis == value)
                     return;
                 _textPainter.textWidthBasis = value;
                 return _selectionHeightStyle;
             }
             set {
-                D.assert(value != null);
                 if (_selectionHeightStyle == value)
                     return;
                 _selectionHeightStyle = value;
                 return _selectionWidthStyle;
             }
             set {
-                D.assert(value != null);
                 if (_selectionWidthStyle == value)
                     return;
                 _selectionWidthStyle = value;
                 return _forceLine;
             }
             set {
-                D.assert(value != null);
                 if (_forceLine == value)
                     return;
                 _forceLine = value;
                 return _readOnly;
             }
             set {
-                D.assert(value != null);
                 if (_readOnly == value)
                     return;
                 _readOnly = value;
         }
 
         void _handleMoveCursorForwardByCharacter(bool extentSelection) {
-            int extentOffset = _textPainter.getOffsetAfter(_selection.extentOffset);
+            int? extentOffset = _textPainter.getOffsetAfter(_selection.extentOffset);
-            int baseOffset = !extentSelection ? extentOffset : _selection.baseOffset;
+            int baseOffset = !extentSelection ? extentOffset.Value : _selection.baseOffset;
-            new TextSelection(baseOffset: baseOffset, extentOffset: extentOffset), SelectionChangedCause.keyboard
+            new TextSelection(baseOffset: baseOffset, extentOffset: extentOffset.Value), SelectionChangedCause.keyboard
-            int extentOffset = _textPainter.getOffsetBefore(_selection.extentOffset);
+            int? extentOffset = _textPainter.getOffsetBefore(_selection.extentOffset);
-            int baseOffset = !extentSelection ? extentOffset : _selection.baseOffset;
+            int baseOffset = !extentSelection ? extentOffset.Value : _selection.baseOffset;
-                new TextSelection(baseOffset: baseOffset, extentOffset: extentOffset), SelectionChangedCause.keyboard
+                new TextSelection(baseOffset: baseOffset, extentOffset: extentOffset.Value), SelectionChangedCause.keyboard
             );
         }
 

com.unity.uiwidgets/Runtime/rendering/flex.cs

 
         public CrossAxisAlignment _crossAxisAlignment;
 
-        public TextDirection textDirection {
+        public TextDirection? textDirection {
             get { return _textDirection; }
             set {
                 if (_textDirection == value) {
             }
         }
 
-        public TextDirection _textDirection;
+        public TextDirection? _textDirection;
-        public VerticalDirection verticalDirection {
+        public VerticalDirection? verticalDirection {
             get { return _verticalDirection; }
             set {
                 if (_verticalDirection == value) {
             }
         }
 
-        public VerticalDirection _verticalDirection;
+        public VerticalDirection? _verticalDirection;
 
         public TextBaseline textBaseline {
             get { return _textBaseline; }
             }
         }
 
-        static bool _startIsTopLeft(Axis direction, TextDirection textDirection,
-            VerticalDirection verticalDirection) {
+        static bool _startIsTopLeft(Axis direction, TextDirection? textDirection,
+            VerticalDirection? verticalDirection) {
             switch (direction) {
                 case Axis.horizontal:
                     switch (textDirection) {
             properties.add(new EnumProperty<MainAxisAlignment>("mainAxisAlignment", mainAxisAlignment));
             properties.add(new EnumProperty<MainAxisSize>("mainAxisSize", mainAxisSize));
             properties.add(new EnumProperty<CrossAxisAlignment>("crossAxisAlignment", crossAxisAlignment));
-            properties.add(new EnumProperty<TextDirection>("textDirection", textDirection, defaultValue: null));
-            properties.add(new EnumProperty<VerticalDirection>("verticalDirection", verticalDirection, defaultValue: null));
+            properties.add(new EnumProperty<TextDirection?>("textDirection", textDirection, defaultValue: null));
+            properties.add(new EnumProperty<VerticalDirection?>("verticalDirection", verticalDirection, defaultValue: null));
             properties.add(new EnumProperty<TextBaseline>("textBaseline", textBaseline, defaultValue: null));
         }
     }

com.unity.uiwidgets/Runtime/rendering/image.cs

         public bool matchTextDirection {
             get { return _matchTextDirection; }
             set {
-                D.assert(value != null);
                 if (value == _matchTextDirection)
                     return;
                 _matchTextDirection = value;
             }
             _resolve();
             D.assert(_resolvedAlignment != null);
-            D.assert(_flipHorizontally != null);
             painting_.paintImage(
                 canvas: context.canvas,
                 rect: offset & size,

com.unity.uiwidgets/Runtime/rendering/layer.cs

     public class TextureLayer : Layer {
         public TextureLayer(
             Rect rect,
-            int textureId,
+            int? textureId,
-            this.textureId = textureId;
+            this.textureId = textureId.Value;
             this.freeze = freeze;
         }
 
             layerOffset = layerOffset ?? Offset.zero;
             D.assert(shader != null);
             D.assert(maskRect != null);
-            D.assert(blendMode != null);
             D.assert(layerOffset != null);
             Rect shiftedMaskRect = layerOffset == Offset.zero ? maskRect : maskRect.shift(layerOffset);
             engineLayer = builder.pushShaderMask(

com.unity.uiwidgets/Runtime/rendering/list_body.cs

 
         AxisDirection _axisDirection;
 
-        public Axis mainAxis {
+        public Axis? mainAxis {
             get { return AxisUtils.axisDirectionToAxis(axisDirection); }
         }
 

com.unity.uiwidgets/Runtime/rendering/sliver.cs

     }
 
     public static class GrowthDirectionUtils {
-        public static AxisDirection applyGrowthDirectionToAxisDirection(
-            AxisDirection axisDirection, GrowthDirection growthDirection) {
+        public static AxisDirection? applyGrowthDirectionToAxisDirection(
+            AxisDirection? axisDirection, GrowthDirection? growthDirection) {
+            D.assert(axisDirection != null);
+            D.assert(growthDirection != null);
             switch (growthDirection) {
                 case GrowthDirection.forward:
                     return axisDirection;
 
     public class SliverConstraints : Constraints, IEquatable<SliverConstraints> {
         public SliverConstraints(
-            AxisDirection axisDirection,
-            GrowthDirection growthDirection,
+            AxisDirection? axisDirection,
+            GrowthDirection? growthDirection,
             ScrollDirection userScrollDirection,
             float scrollOffset,
             float precedingScrollExtent,
-            AxisDirection crossAxisDirection,
+            AxisDirection? crossAxisDirection,
-            this.axisDirection = axisDirection;
-            this.growthDirection = growthDirection;
+            D.assert(axisDirection != null);
+            D.assert(growthDirection != null);
+            D.assert(crossAxisDirection != null);
+            this.axisDirection = axisDirection.Value;
+            this.growthDirection = growthDirection.Value;
             this.userScrollDirection = userScrollDirection;
             this.scrollOffset = scrollOffset;
             this.precedingScrollExtent = precedingScrollExtent;
-            this.crossAxisDirection = crossAxisDirection;
+            this.crossAxisDirection = crossAxisDirection.Value;
             this.viewportMainAxisExtent = viewportMainAxisExtent;
             this.remainingCacheExtent = remainingCacheExtent;
             this.cacheOrigin = cacheOrigin;
             );
         }
 
-        public readonly AxisDirection axisDirection;
+        public readonly AxisDirection? axisDirection;
-        public readonly GrowthDirection growthDirection;
+        public readonly GrowthDirection? growthDirection;
 
         public readonly ScrollDirection userScrollDirection;
 
 
         public readonly float crossAxisExtent;
 
-        public readonly AxisDirection crossAxisDirection;
+        public readonly AxisDirection? crossAxisDirection;
 
         public readonly float viewportMainAxisExtent;
 
 
-        public Axis axis {
+        public Axis? axis {
+                D.assert(axisDirection != null);
+                D.assert(growthDirection != null);
-                        return growthDirection;
+                        return growthDirection.Value;
                     case AxisDirection.up:
                     case AxisDirection.left:
                         switch (growthDirection) {

com.unity.uiwidgets/Runtime/rendering/sliver_padding.cs

         float?  beforePadding {
             get {
                 D.assert(constraints != null);
-                D.assert(constraints.axisDirection != null);
                 D.assert(resolvedPadding != null);
                 switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
                     case AxisDirection.up:
         float?  afterPadding { 
             get { 
                 D.assert(constraints != null);
-                D.assert(constraints.axisDirection != null);
                 D.assert(resolvedPadding != null);
                 switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
                     case AxisDirection.up:
             D.assert(child != null);
             D.assert(child == this.child);
             D.assert(constraints != null);
-            D.assert(constraints.axisDirection != null);
             D.assert(resolvedPadding != null);
             switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(constraints.axisDirection, constraints.growthDirection)) {
               case AxisDirection.up:

com.unity.uiwidgets/Runtime/rendering/viewport.cs

         RenderAbstractViewport
         where ParentDataClass : ParentData, ContainerParentDataMixin<RenderSliver> {
         protected RenderViewportBase(
-            AxisDirection axisDirection = AxisDirection.down,
-            AxisDirection crossAxisDirection = AxisDirection.right,
+            AxisDirection? axisDirection = AxisDirection.down,
+            AxisDirection? crossAxisDirection = AxisDirection.right,
+            D.assert(axisDirection != null);
+            D.assert(crossAxisDirection != null);
-            D.assert(AxisUtils.axisDirectionToAxis(axisDirection) != AxisUtils.axisDirectionToAxis(crossAxisDirection));
+            D.assert(AxisUtils.axisDirectionToAxis(axisDirection.Value) != AxisUtils.axisDirectionToAxis(crossAxisDirection.Value));
-            _axisDirection = axisDirection;
-            _crossAxisDirection = crossAxisDirection;
+            _axisDirection = axisDirection.Value;
+            _crossAxisDirection = crossAxisDirection.Value;
             _offset = offset;
             _cacheExtent = cacheExtent ?? RenderViewportUtils.defaultCacheExtent;
             _cacheExtentStyle = cacheExtentStyle;
 
         AxisDirection _crossAxisDirection;
 
-        public Axis axis {
+        public Axis? axis {
             get { return AxisUtils.axisDirectionToAxis(axisDirection); }
         }
 
 
                 float offset = 0.0f;
 
-                GrowthDirection growthDirection = pivotParent.constraints.growthDirection;
+                GrowthDirection? growthDirection = pivotParent.constraints.growthDirection;
                 switch (GrowthDirectionUtils.applyGrowthDirectionToAxisDirection(axisDirection, growthDirection)) {
                     case AxisDirection.up:
                         switch (growthDirection) {
 
     public class RenderViewport : RenderViewportBase<SliverPhysicalContainerParentData> {
         public RenderViewport(
-            AxisDirection axisDirection = AxisDirection.down,
-            AxisDirection crossAxisDirection = AxisDirection.right,
+            AxisDirection? axisDirection = AxisDirection.down,
+            AxisDirection? crossAxisDirection = AxisDirection.right,
-            float anchor = 0.0f,
+            float? anchor = 0.0f,
-            float cacheExtent = RenderViewportUtils.defaultCacheExtent,
+            float? cacheExtent = RenderViewportUtils.defaultCacheExtent,
-        ) : base(axisDirection, crossAxisDirection, offset, cacheExtent,cacheExtentStyle) {
+        ) : base(axisDirection, crossAxisDirection, offset, cacheExtent, cacheExtentStyle) {
-            _anchor = anchor;
+            _anchor = anchor.Value;
             _center = center;
             addAll(children);
             if (center == null && firstChild != null) {
         protected override float scrollOffsetOf(RenderSliver child, float scrollOffsetWithinChild) {
             D.assert(child.parent == this);
 
-            GrowthDirection growthDirection = child.constraints.growthDirection;
+            GrowthDirection? growthDirection = child.constraints.growthDirection;
             switch (growthDirection) {
                 case GrowthDirection.forward: {
                     float scrollOffsetToChild = 0.0f;
         protected override float maxScrollObstructionExtentBefore(RenderSliver child) {
             D.assert(child.parent == this);
 
-            GrowthDirection growthDirection = child.constraints.growthDirection;
+            GrowthDirection? growthDirection = child.constraints.growthDirection;
             switch (growthDirection) {
                 case GrowthDirection.forward: {
                     float pinnedExtent = 0.0f;
 
     public class RenderShrinkWrappingViewport : RenderViewportBase<SliverLogicalContainerParentData> {
         public RenderShrinkWrappingViewport(
-            AxisDirection axisDirection = AxisDirection.down,
-            AxisDirection crossAxisDirection = AxisDirection.right,
+            AxisDirection? axisDirection = AxisDirection.down,
+            AxisDirection? crossAxisDirection = AxisDirection.right,
             ViewportOffset offset = null,
             List<RenderSliver> children = null
         ) : base(

com.unity.uiwidgets/Runtime/services/keyboard_key.cs

         }
 
         public LogicalKeyboardKey(long keyId, string debugName = null, string keyLabel = null) : base() {
-            D.assert(keyId != null);
             this.keyId = keyId;
             this.debugName = debugName;
             this.keyLabel = keyLabel;
 
     public class PhysicalKeyboardKey : KeyboardKey, IEquatable<PhysicalKeyboardKey> {
         protected PhysicalKeyboardKey(int usbHidUsage, string debugName = null) {
-            D.assert(usbHidUsage != null);
             this.usbHidUsage = usbHidUsage;
             this.debugName = debugName;
         }

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

 
         public FocusableActionDetector(
             Key key = null,
-            bool enabled = true,
+            bool? enabled = true,
-            bool autofocus = false,
+            bool? autofocus = false,
             Dictionary<LogicalKeySet, Intent> shortcuts = null,
             Dictionary<LocalKey, ActionFactory> actions = null,
             ValueChanged<bool> onShowFocusHighlight = null,
             D.assert(enabled != null);
             D.assert(autofocus != null);
             D.assert(child != null);
-            this.enabled = enabled;
+            this.enabled = enabled.Value;
-            this.autofocus = autofocus;
+            this.autofocus = autofocus.Value;
             this.shortcuts = shortcuts;
             this.actions = actions;
             this.onShowFocusHighlight = onShowFocusHighlight;

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

 
 
     public static class LayoutUtils {
-        public static AxisDirection getAxisDirectionFromAxisReverseAndDirectionality(
+        public static AxisDirection? getAxisDirectionFromAxisReverseAndDirectionality(
             BuildContext context,
             Axis axis,
             bool reverse
                     D.assert(WidgetsD.debugCheckHasDirectionality(context));
                     TextDirection textDirection = Directionality.of(context);
-                    AxisDirection axisDirection = AxisUtils.textDirectionToAxisDirection(textDirection);
+                    AxisDirection? axisDirection = AxisUtils.textDirectionToAxisDirection(textDirection);
                     return reverse ? AxisUtils.flipAxisDirection(axisDirection) : axisDirection;
                 case Axis.vertical:
                     return reverse ? AxisDirection.up : AxisDirection.down;

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

         public void unfocus(
             UnfocusDisposition disposition = UnfocusDisposition.scope
         ) {
-            D.assert(disposition != null);
             if (!hasFocus && (_manager == null || _manager._markedForFocus != this)) {
                 return;
             }
             }
         }
 
-        public override void _doRequestFocus( bool findFirstFocus = false) { 
-            D.assert(findFirstFocus != null);
-
+        public override void _doRequestFocus( bool findFirstFocus = false) {
             // It is possible that a previously focused child is no longer focusable.
             while (focusedChild != null && !focusedChild.canRequestFocus)
               _focusedChildren.removeLast();

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

         protected override Widget buildViewport(
             BuildContext context,
             ViewportOffset offset,
-            AxisDirection axisDirection,
+            AxisDirection? axisDirection,
             List<Widget> slivers
         ) {
             D.assert(!shrinkWrap);
     public class NestedScrollViewViewport : Viewport {
         public NestedScrollViewViewport(
             Key key = null,
-            AxisDirection axisDirection = AxisDirection.down,
+            AxisDirection? axisDirection = AxisDirection.down,
             AxisDirection crossAxisDirection = AxisDirection.right,
             float anchor = 0.0f,
             ViewportOffset offset = null,
 
         public override void updateRenderObject(BuildContext context, RenderObject _renderObject) {
             RenderNestedScrollViewViewport renderObject = _renderObject as RenderNestedScrollViewViewport;
-            renderObject.axisDirection = axisDirection;
-            renderObject.crossAxisDirection = crossAxisDirection ??
-                                              getDefaultCrossAxisDirection(context, axisDirection);
+            renderObject.axisDirection = axisDirection.Value;
+            renderObject.crossAxisDirection = (crossAxisDirection ?? getDefaultCrossAxisDirection(context, axisDirection)).Value;
             if (crossAxisDirection == null) {
                 renderObject.anchor = anchor;
             }
 
     public class RenderNestedScrollViewViewport : RenderViewport {
         public RenderNestedScrollViewViewport(
-            AxisDirection axisDirection = AxisDirection.down,
-            AxisDirection crossAxisDirection = AxisDirection.right,
+            AxisDirection? axisDirection = AxisDirection.down,
+            AxisDirection? crossAxisDirection = AxisDirection.right,
             ViewportOffset offset = null,
             float anchor = 0.0f,
             List<RenderSliver> children = null,

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

 
         public readonly AxisDirection axisDirection;
 
-        public Axis axis {
+        public Axis? axis {
             get { return AxisUtils.axisDirectionToAxis(axisDirection); }
         }
 
             base.didUpdateWidget(_oldWidget);
             GlowingOverscrollIndicator oldWidget = _oldWidget as GlowingOverscrollIndicator;
             if (oldWidget.color != widget.color || oldWidget.axis != widget.axis) {
+                D.assert(widget.axis != null);
-                _leadingController.axis = widget.axis;
+                _leadingController.axis = widget.axis.Value;
-                _trailingController.axis = widget.axis;
+                _trailingController.axis = widget.axis.Value;
             }
         }
 
         public _GlowController(
             TickerProvider vsync,
             Color color,
-            Axis axis
+            Axis? axis
+            D.assert(axis != null);
-            _axis = axis;
+            _axis = axis.Value;
             _glowController = new AnimationController(vsync: vsync);
             _glowController.addStatusListener(_changePhase);
             Animation<float> decelerator = new CurvedAnimation(

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

             _lastReportedPage = widget.controller.initialPage;
         }
 
-        AxisDirection _getDirection(BuildContext context) {
+        AxisDirection? _getDirection(BuildContext context) {
-                    AxisDirection axisDirection = AxisUtils.textDirectionToAxisDirection(textDirection);
+                    AxisDirection? axisDirection = AxisUtils.textDirectionToAxisDirection(textDirection);
                     return widget.reverse ? AxisUtils.flipAxisDirection(axisDirection) : axisDirection;
                 case Axis.vertical:
                     return widget.reverse ? AxisDirection.up : AxisDirection.down;
         }
 
         public override Widget build(BuildContext context) {
-            AxisDirection axisDirection = _getDirection(context);
+            AxisDirection? axisDirection = _getDirection(context);
             ScrollPhysics physics = new _ForceImplicitScrollPhysics(
                 allowImplicitScrolling: widget.allowImplicitScrolling
             ).applyTo(widget.pageSnapping

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

             );
         }
 
-        public static Axis axis(this ScrollMetrics it) {
+        public static Axis? axis(this ScrollMetrics it) {
             return AxisUtils.axisDirectionToAxis(axisDirection: it.axisDirection);
         }
 

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

         public readonly DragStartBehavior dragStartBehavior;
         public readonly ScrollViewKeyboardDismissBehavior keyboardDismissBehavior;
 
-        protected AxisDirection getDirection(BuildContext context) {
+        protected AxisDirection? getDirection(BuildContext context) {
             return LayoutUtils.getAxisDirectionFromAxisReverseAndDirectionality(
                 context, scrollDirection, reverse);
         }
         protected virtual Widget buildViewport(
             BuildContext context,
             ViewportOffset offset,
-            AxisDirection axisDirection,
+            AxisDirection? axisDirection,
             List<Widget> slivers
         ) {
             if (shrinkWrap) {
 
         public override Widget build(BuildContext context) {
             List<Widget> slivers = buildSlivers(context);
-            AxisDirection axisDirection = getDirection(context);
+            AxisDirection? axisDirection = getDirection(context);
 
             ScrollController scrollController = primary ? PrimaryScrollController.of(context) : controller;
 

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

     public class Scrollable : StatefulWidget {
         public Scrollable(
             Key key = null,
-            AxisDirection axisDirection = AxisDirection.down,
+            AxisDirection? axisDirection = AxisDirection.down,
             ScrollController controller = null,
             ScrollPhysics physics = null,
             ViewportBuilder viewportBuilder = null,
+            D.assert(axisDirection != null);
-            this.axisDirection = axisDirection;
+            this.axisDirection = axisDirection.Value;
             this.controller = controller;
             this.physics = physics;
             this.viewportBuilder = viewportBuilder;
 
         public readonly DragStartBehavior dragStartBehavior;
 
-        public Axis axis {
+        public Axis? axis {
             get { return AxisUtils.axisDirectionToAxis(axisDirection); }
         }
 
         bool _shouldIgnorePointer = false;
 
         bool _lastCanDrag;
-        Axis _lastAxisDirection;
+        Axis? _lastAxisDirection;
 
         public void setCanDrag(bool canDrag) {
             if (canDrag == _lastCanDrag && (!canDrag || widget.axis == _lastAxisDirection)) {

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

                 if (length == 2) {
                     // No need to sort if there's two keys, just compare them.
                     return h1 < h2
-                        ? ((h1 != null ? h1.GetHashCode() : 0) * 397) ^ h2.GetHashCode()
-                        : ((h2 != null ? h2.GetHashCode() : 0) * 397) ^ h1.GetHashCode();
+                        ? ((h1.GetHashCode()) * 397) ^ h2.GetHashCode()
+                        : ((h2.GetHashCode()) * 397) ^ h1.GetHashCode();
                 }
 
                 // Sort key hash codes and feed to hashList to ensure the aggregate

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

 
         AxisDirection _axisDirection;
 
-        public Axis axis {
+        public Axis? axis {
             get { return AxisUtils.axisDirectionToAxis(axisDirection); }
         }
 

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

             Key key = null,
             float opacity = 0f,
             Widget sliver = null) : base(key: key, child: sliver) { 
-            D.assert(opacity != null && opacity >= 0.0 && opacity <= 1.0);
+            D.assert(opacity >= 0.0 && opacity <= 1.0);
             this.opacity = opacity;
         }
 

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

     }
     public class _RenderSliverFractionalPadding : RenderSliverEdgeInsetsPadding {
         public _RenderSliverFractionalPadding(
-            float viewportFraction = 0
+            float? viewportFraction = 0
-            _viewportFraction = viewportFraction;
+            _viewportFraction = viewportFraction.Value;
         }
 
         SliverConstraints _lastResolvedConstraints;
             set {
-                D.assert(value != null);
                 if (_viewportFraction == value)
                     return;
                 _viewportFraction = value;
         void _resolve() {
             if (_resolvedPadding != null && _lastResolvedConstraints == constraints)
               return;
-
-            D.assert(constraints.axis != null);
-             float paddingValue = constraints.viewportMainAxisExtent * viewportFraction;
+            
+            float paddingValue = constraints.viewportMainAxisExtent * viewportFraction;
             _lastResolvedConstraints = constraints;
             switch (constraints.axis) {
               case Axis.horizontal:
                 _resolvedPadding = EdgeInsets.symmetric(vertical: paddingValue);
                 break;
             }
-
-            return;
         }
 
         protected override void performLayout() {

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

-using System;
-using System.Collections.Generic;
-using Unity.UIWidgets.painting;
-using Unity.UIWidgets.service;
-using Unity.UIWidgets.ui;
-using UnityEngine;
-using Brightness = Unity.UIWidgets.ui.Brightness;
 
 namespace Unity.UIWidgets.widgets {
     public class Spacer : StatelessWidget {
-            int flex = 1)
+            int? flex = 1)
-            this.flex = flex;
+            this.flex = flex.Value;
         }
         public readonly int flex;
 

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

             LayerLink endHandleLayerLink = null,
             RenderEditable renderObject = null,
             TextSelectionControls selectionControls = null,
-            bool handlesVisible = false,
+            bool? handlesVisible = false,
             TextSelectionDelegate selectionDelegate = null,
             DragStartBehavior dragStartBehavior = DragStartBehavior.start, 
             VoidCallback onSelectionHandleTapped = null) {
-            _handlesVisible = handlesVisible;
+            _handlesVisible = handlesVisible.Value;
             this.context = context;
             this.debugRequiredFor = debugRequiredFor;
             this.toolbarLayerLink = toolbarLayerLink;
         }
         protected void onTapDown(TapDownDetails details) {
             renderEditable.handleTapDown(details);
-            PointerDeviceKind kind = details.kind;
+            PointerDeviceKind? kind = details.kind;
             _shouldShowSelectionToolbar = kind == null
                               || kind == PointerDeviceKind.touch
                               || kind == PointerDeviceKind.stylus;

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

     public class TickerMode : StatelessWidget {
         public TickerMode(
             Key key = null,
-            bool enabled = true,
+            bool? enabled = true,
-            this.enabled = enabled;
+            this.enabled = enabled.Value;
             this.child = child;
         }
 

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

     public class Viewport : MultiChildRenderObjectWidget {
         public Viewport(
             Key key = null,
-            AxisDirection axisDirection = AxisDirection.down,
+            AxisDirection? axisDirection = AxisDirection.down,
             AxisDirection? crossAxisDirection = null,
             float anchor = 0.0f,
             ViewportOffset offset = null,
             this.cacheExtentStyle = cacheExtentStyle;
         }
 
-        public readonly AxisDirection axisDirection;
+        public readonly AxisDirection? axisDirection;
 
         public readonly AxisDirection? crossAxisDirection;
 
         
         public readonly CacheExtentStyle cacheExtentStyle;
 
-        public static AxisDirection getDefaultCrossAxisDirection(BuildContext context, AxisDirection axisDirection) {
+        public static AxisDirection? getDefaultCrossAxisDirection(BuildContext context, AxisDirection? axisDirection) {
+            D.assert(axisDirection != null);
             switch (axisDirection) {
                 case AxisDirection.up:
                     return AxisUtils.textDirectionToAxisDirection(Directionality.of(context));
                 case AxisDirection.left:
                     return AxisDirection.down;
             }
-
-
-            throw new Exception("unknown axisDirection");
+            return null;
         }
 
 
 
         public override void updateRenderObject(BuildContext context, RenderObject renderObjectRaw) {
             var renderObject = (RenderViewport) renderObjectRaw;
-            renderObject.axisDirection = axisDirection;
-            renderObject.crossAxisDirection = crossAxisDirection ?? getDefaultCrossAxisDirection(context, axisDirection);
+            renderObject.axisDirection = axisDirection.Value;
+            renderObject.crossAxisDirection = (crossAxisDirection ?? getDefaultCrossAxisDirection(context, axisDirection)).Value;
             renderObject.anchor = anchor;
             renderObject.offset = offset;
             renderObject.cacheExtent = cacheExtent ?? RenderViewportUtils.defaultCacheExtent;
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             base.debugFillProperties(properties);
-            properties.add(new EnumProperty<AxisDirection>("axisDirection", axisDirection));
+            properties.add(new EnumProperty<AxisDirection?>("axisDirection", axisDirection));
             properties.add(new EnumProperty<AxisDirection?>("crossAxisDirection", crossAxisDirection,
                 defaultValue: foundation_.kNullDefaultValue));
             properties.add(new FloatProperty("anchor", anchor));
     public class ShrinkWrappingViewport : MultiChildRenderObjectWidget {
         public ShrinkWrappingViewport(
             Key key = null,
-            AxisDirection axisDirection = AxisDirection.down,
+            AxisDirection? axisDirection = AxisDirection.down,
             AxisDirection? crossAxisDirection = null,
             ViewportOffset offset = null,
             List<Widget> slivers = null
             this.offset = offset;
         }
 
-        public readonly AxisDirection axisDirection;
+        public readonly AxisDirection? axisDirection;
 
         public readonly AxisDirection? crossAxisDirection;
 
 
         public override void updateRenderObject(BuildContext context, RenderObject renderObjectRaw) {
             var renderObject = (RenderShrinkWrappingViewport) renderObjectRaw;
-            renderObject.axisDirection = axisDirection;
-            renderObject.crossAxisDirection = crossAxisDirection
-                                              ?? Viewport.getDefaultCrossAxisDirection(context, axisDirection);
+            renderObject.axisDirection = axisDirection.Value;
+            renderObject.crossAxisDirection = (crossAxisDirection ?? Viewport.getDefaultCrossAxisDirection(context, axisDirection)).Value;
-            properties.add(new EnumProperty<AxisDirection>("axisDirection", axisDirection));
+            properties.add(new EnumProperty<AxisDirection?>("axisDirection", axisDirection));
             properties.add(new EnumProperty<AxisDirection?>("crossAxisDirection", crossAxisDirection,
                 defaultValue: foundation_.kNullDefaultValue));
             properties.add(new DiagnosticsProperty<ViewportOffset>("offset", offset));