fix more warnings

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

             EdgeInsetsGeometry padding = null,
             Color color = null,
             Color disabledColor = null,
-            float minSize = 44.0f,
+            float? minSize = 44.0f,
             float pressedOpacity = 0.4f,
             BorderRadius borderRadius = null,
             VoidCallback onPressed = null
             Widget child = null,
             EdgeInsetsGeometry padding = null,
             Color disabledColor = null,
-            float minSize = 44.0f,
+            float? minSize = 44.0f,
             float pressedOpacity = 0.4f,
             BorderRadius borderRadius = null,
             VoidCallback onPressed = null
 
         public readonly VoidCallback onPressed;
 
-        public readonly float minSize;
+        public readonly float? minSize;
 
         public readonly float pressedOpacity;
 
                     constraints: widget.minSize == null
                     ? new BoxConstraints() : 
                     new BoxConstraints(
-                        minWidth: widget.minSize,
-                        minHeight: widget.minSize
+                        minWidth: widget.minSize.Value,
+                        minHeight: widget.minSize.Value
                     ),
                     child: new FadeTransition(
                         opacity: _opacityAnimation,

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

             if (resolvable == null)
                 return null;
             D.assert(context != null);
-
-           
-            //var resolveColor =  (resolvable is CupertinoDynamicColor) ? ((CupertinoDynamicColor)resolvable).resolveFrom(context, nullOk: nullOk) : resolvable;
+            
-                int i = 0;
-                int j = 0;
-
             return resolveColor;
         }
 
 
         public override int GetHashCode() {
             unchecked {
-                var hashCode = (value != null ? value.GetHashCode() : 0);
+                var hashCode = (value.GetHashCode());
                 hashCode = (hashCode * 397) ^(color != null ? color.GetHashCode() : 0);
                 hashCode = (hashCode * 397) ^ (darkColor != null ? darkColor.GetHashCode() : 0);
                 hashCode = (hashCode * 397) ^ (highContrastColor != null ? highContrastColor.GetHashCode() : 0);

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

     }
     public delegate void _DismissCallback(
         BuildContext context,
-        float scale,
+        float? scale,
         float opacity
     );
 
     public class _ContextMenuRoute : PopupRoute { 
         public _ContextMenuRoute(
             List<Widget> actions = null, 
-            _ContextMenuLocation contextMenuLocation = default, 
+            _ContextMenuLocation? contextMenuLocation = null, 
             string barrierLabel = null, 
             _ContextMenuPreviewBuilderChildless builder = null, 
             ImageFilter filter = null, 
             this.barrierLabel = barrierLabel;
             _actions = actions;
             _builder = builder;
-            _contextMenuLocation = contextMenuLocation;
+            _contextMenuLocation = contextMenuLocation.Value;
+        
         public readonly static Color _kModalBarrierColor = new Color(0x6604040F);
         public readonly TimeSpan _kModalPopupTransitionDuration =new TimeSpan(0, 0, 0, 0, 335);
         public readonly List<Widget> _actions;
         public bool _internalOffstage = false;
         public Orientation _lastOrientation;
         public readonly Rect _previousChildRect;
-        public float _scale = 1.0f;
+        public float? _scale = 1.0f;
-        public readonly static CurveTween _curve = new CurveTween(
+        public static readonly CurveTween _curve = new CurveTween(
-        public readonly static  CurveTween _curveReverse = new CurveTween(
+        public static readonly  CurveTween _curveReverse = new CurveTween(
-        public readonly static RectTween _rectTween = new RectTween();
-        public readonly static Animatable<Rect> _rectAnimatable = _rectTween.chain(_curve);
-        public readonly static RectTween _rectTweenReverse = new RectTween();
-        public readonly static Animatable<Rect> _rectAnimatableReverse = _rectTweenReverse.chain(_curveReverse);
+        public static readonly RectTween _rectTween = new RectTween();
+        public static readonly Animatable<Rect> _rectAnimatable = _rectTween.chain(_curve);
+        public static readonly RectTween _rectTweenReverse = new RectTween();
+        public static readonly Animatable<Rect> _rectAnimatableReverse = _rectTweenReverse.chain(_curveReverse);
-        public readonly static RectTween _sheetRectTween = new RectTween();
+        public static readonly RectTween _sheetRectTween = new RectTween();
-        public readonly static  Tween< float> _sheetScaleTween = new FloatTween(0.0f,0.0f);
-        public readonly static  Animatable< float> _sheetScaleAnimatable = _sheetScaleTween.chain(_curve);
-        public readonly static  Animatable< float> _sheetScaleAnimatableReverse = _sheetScaleTween.chain(_curveReverse);
+        public static readonly  Tween<float?> _sheetScaleTween = new NullableFloatTween(0.0f,0.0f);
+        public static readonly  Animatable<float?> _sheetScaleAnimatable = _sheetScaleTween.chain(_curve);
+        public static readonly  Animatable<float?> _sheetScaleAnimatableReverse = _sheetScaleTween.chain(_curveReverse);
         public readonly Tween< float> _opacityTween = new FloatTween(begin: 0.0f, end: 1.0f);
         public Animation< float> _sheetOpacity;
       
                     return target3 & sheetRect.size;
             }
         } 
-        public void _onDismiss(BuildContext context, float scale, float opacity) { 
+        public void _onDismiss(BuildContext context, float? scale, float opacity) { 
             _scale = scale;
             _opacityTween.end = opacity;
             _sheetOpacity = _opacityTween.animate(
         public void _updateTweenRects() { 
             Rect childRect = _scale == null 
                 ? CupertinoContextMenuUtils._getRect(_childGlobalKey) 
-                : _getScaledRect(_childGlobalKey, _scale); 
+                : _getScaledRect(_childGlobalKey, _scale.Value);
             _rectTween.begin = _previousChildRect; 
             _rectTween.end = childRect; 
             Rect childRectOriginal = CupertinoContextMenuUtils.fromCenter(
                         Rect sheetRect = reverse
                             ? _sheetRectAnimatableReverse.evaluate(animation)
                             : _sheetRectAnimatable.evaluate(animation);
-                        float sheetScale = reverse
+                        float? sheetScale = reverse
                             ? _sheetScaleAnimatableReverse.evaluate(animation)
                             : _sheetScaleAnimatable.evaluate(animation); 
                         List<Widget> widgets = new List<Widget>(); 
                                     opacity: _sheetOpacity.value, 
                                     child: Transform.scale( 
                                         alignment: getSheetAlignment(_contextMenuLocation),
-                                        scale: sheetScale, 
+                                        scale: sheetScale ?? 1.0f, 
                                         child: new _ContextMenuSheet(
                                             key: _sheetGlobalKey, 
                                             actions: _actions, 
     public _ContextMenuSheet(
       Key key = null,
       List<Widget> actions = null,
-      _ContextMenuLocation contextMenuLocation = default,
-      Orientation orientation = default
+      _ContextMenuLocation? contextMenuLocation = null,
+      Orientation? orientation = null
-      _contextMenuLocation = contextMenuLocation;
-      _orientation = orientation;
+      _contextMenuLocation = contextMenuLocation.Value;
+      _orientation = orientation.Value;
       this.actions = actions;
     }
     public readonly List<Widget> actions;

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

                 return;
             }
             TextDirection textDirection = configuration.textDirection;
-            D.assert(textDirection != null);
             float deltaX = 0.0f;
             switch (textDirection) {
                 case TextDirection.rtl:

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

         Animation<float> _fadeoutOpacityAnimation;
         AnimationController _thicknessAnimationController;
         
-        float _dragScrollbarPositionY;
+        float? _dragScrollbarPositionY;
         Timer _fadeoutTimer;
         Drag _drag;
 
             if (!_checkVertical()) {
                 return;
             }
-            _dragScrollbar(details.localPosition.dy - _dragScrollbarPositionY);
+            D.assert(_dragScrollbarPositionY != null);
+            _dragScrollbar(details.localPosition.dy - _dragScrollbarPositionY.Value);
             _dragScrollbarPositionY = details.localPosition.dy;
         }
 
         void _handleDragScrollEnd(float trackVelocityY) {
             _startFadeoutTimer();
             _thicknessAnimationController.reverse();
-            _dragScrollbarPositionY = 0.0f;
+            _dragScrollbarPositionY = null;
             float scrollVelocityY = _painter.getTrackToScroll(trackVelocityY);
             _drag?.end(new DragEndDetails(
               primaryVelocity: -scrollVelocityY,

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

             TextDirection? textDirection = null
         ) : base(additionalConstraints: BoxConstraints.tightFor(width: SliderUtils._kSliderWidth,
             height: SliderUtils._kSliderHeight)) {
-            D.assert(value >= 0.0f && value <= 1.0f && value != null) ;
+            D.assert(value >= 0.0f && value <= 1.0f);
             _value = value;
             _divisions = divisions;
             _activeColor = activeColor;

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

               return;
             AnimationController controller = _highlightControllers[at];
             D.assert(!forward || controller != null);
-            controller?.animateTo(forward ? 1 : 0, duration:    CupertinoSlidingSegmentedControlsUtils._kHighlightAnimationDuration, curve: Curves.ease);
+            controller?.animateTo(forward ? 1 : 0, duration: CupertinoSlidingSegmentedControlsUtils._kHighlightAnimationDuration, curve: Curves.ease);
     }
         T _highlighted; 
         public T highlighted{
             widget.onValueChanged(_highlighted);
         }
 
-        public T indexToKey(int index) {
-            return index == null ? default : keys[index];
+        public T indexToKey(int? index) {
+            return index == null ? default : keys[index.Value];
         }
 
         public override Widget build(BuildContext context) {
     public class _ChildAnimationManifest { 
         public _ChildAnimationManifest(
             float opacity = 1f,
-            float separatorOpacity = 0f) {
-                D.assert(separatorOpacity != null);
-                D.assert(opacity != null);
+            float separatorOpacity = 0f
+            ){
+        
         float opacity; 
         Tween<float> opacityTween;
         public float separatorOpacity;
   }
 
   void _playThumbScaleAnimation(bool isExpanding = false) {
-    D.assert(isExpanding != null);
-    _thumbScaleTween = new FloatTween(begin: currentThumbScale, end: isExpanding ? 1 : CupertinoSlidingSegmentedControlsUtils._kMinThumbScale);
+      _thumbScaleTween = new FloatTween(begin: currentThumbScale, end: isExpanding ? 1 : CupertinoSlidingSegmentedControlsUtils._kMinThumbScale);
     state.thumbScaleController.animateWith(CupertinoSlidingSegmentedControlsUtils._kThumbSpringAnimationSimulation);
   }
 

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

             oldPainter = (_TextSelectionHandlePainter)oldPainter;
             return color != ((_TextSelectionHandlePainter)oldPainter).color;
         }
-
-        public bool? hitTest(Offset position) {
-            return null;
-        }
-
-        public void addListener(VoidCallback listener) {
-           base.addListener(listener);
-        }
-
-        public void removeListener(VoidCallback listener) {
-            base.removeListener(listener);
-        }
     }
 
     public delegate bool Predicate(TextSelectionDelegate _delegate);

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

         }
 
 
-        public new CupertinoTextThemeData copyWith(
+        public CupertinoTextThemeData copyWith(
             Color primaryColor = null,
             TextStyle textStyle = null,
             TextStyle actionTextStyle = null,

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

                 var timeStamp = datum.timeStamp;
                 var kind = datum.kind;
                 // TODO: datum.signalKind is not nullable, "else" could not be reached
-                if (datum.signalKind == null || datum.signalKind == ui.PointerSignalKind.none) {
+                if (datum.signalKind == ui.PointerSignalKind.none) {
                     switch (datum.change) {
                         case PointerChange.add: {
                             yield return new PointerAddedEvent(

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

             GestureForceInterpolation interpolation = null )
             : base(debugOwner: debugOwner, kind: kind) {
             interpolation = interpolation ?? _inverseLerp;
-            D.assert(startPressure != null);
-            D.assert(peakPressure != null);
-            D.assert(interpolation != null);
             D.assert(peakPressure > startPressure);
             this.startPressure = startPressure;
             this.peakPressure = peakPressure;
         float _lastPressure;
         _ForceState _state = _ForceState.ready;
 
-        public override void addAllowedPointer(PointerDownEvent Event) {
+        public override void addAllowedPointer(PointerEvent Event) {
             if (!(Event is PointerUpEvent) && Event.pressureMax <= 1.0f) {
                 resolve(GestureDisposition.rejected);
             }

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

             }
         }
 
-        public override void addAllowedPointer(PointerDownEvent evt) {
+        public override void addAllowedPointer(PointerEvent evt) {
             startTrackingPointer(evt.pointer, evt.transform);
             _velocityTrackers[evt.pointer] = new VelocityTracker();
             if (_state == _DragState.ready) {

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

 
         Dictionary<int, T> _pointers = new Dictionary<int, T>();
 
-        public override void addAllowedPointer(PointerDownEvent pEvent) {
+        public override void addAllowedPointer(PointerEvent pEvent) {
+            var _pEvent = (PointerDownEvent) pEvent;
+            D.assert(_pEvent != null);
-            D.assert(pEvent.position != null);
-            D.assert(!_pointers.ContainsKey(pEvent.pointer));
+            D.assert(_pEvent.position != null);
+            D.assert(!_pointers.ContainsKey(_pEvent.pointer));
-            T state = createNewPointerState(pEvent);
-            _pointers[pEvent.pointer] = state;
-            GestureBinding.instance.pointerRouter.addRoute(pEvent.pointer, _handleEvent);
-            state._setArenaEntry(GestureBinding.instance.gestureArena.add(pEvent.pointer, this));
+            T state = createNewPointerState(_pEvent);
+            _pointers[_pEvent.pointer] = state;
+            GestureBinding.instance.pointerRouter.addRoute(_pEvent.pointer, _handleEvent);
+            state._setArenaEntry(GestureBinding.instance.gestureArena.add(_pEvent.pointer, this));
         }
 
         public abstract T createNewPointerState(PointerDownEvent pEvent);

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

         _TapTracker _firstTap;
         readonly Dictionary<int, _TapTracker> _trackers = new Dictionary<int, _TapTracker>();
 
-        public override void addAllowedPointer(PointerDownEvent evt) {
+        public override void addAllowedPointer(PointerEvent evt) {
             if (_firstTap != null) {
                 if (!_firstTap.isWithinGlobalTolerance(evt, Constants.kDoubleTapSlop)) {
                     // Ignore out-of-bounds second taps.
 
         readonly Dictionary<int, _TapGesture> _gestureMap = new Dictionary<int, _TapGesture>();
 
-        public override void addAllowedPointer(PointerDownEvent evt) {
+        public override void addAllowedPointer(PointerEvent evt) {
             D.assert(!_gestureMap.ContainsKey(evt.pointer));
             _gestureMap[evt.pointer] = new _TapGesture(
                 gestureRecognizer: this,

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

             }
         }
 
-        public abstract void addAllowedPointer(PointerDownEvent evt);
+        public abstract void addAllowedPointer(PointerEvent evt);
 
         protected virtual void handleNonAllowedPointer(PointerDownEvent evt) {
         }
 
         Timer _timer;
 
-        public override void addAllowedPointer(PointerDownEvent evt) {
-            startTrackingPointer(evt.pointer, evt.transform);
+        public override void addAllowedPointer(PointerEvent evt) {
+            var _evt = (PointerDownEvent) evt;
+            D.assert(_evt != null);
+            startTrackingPointer(_evt.pointer, _evt.transform);
-                primaryPointer = evt.pointer;
-                initialPosition = new OffsetPair(local: evt.localPosition, global: evt.position);
+                primaryPointer = _evt.pointer;
+                initialPosition = new OffsetPair(local: _evt.localPosition, global: _evt.position);
-                    _timer = Timer.create(deadline.Value, () => didExceedDeadlineWithEvent(evt));
+                    _timer = Timer.create(deadline.Value, () => didExceedDeadlineWithEvent(_evt));
                 }
             }
         }

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

             return angle2 - angle1;
         }
 
-        public override void addAllowedPointer(PointerDownEvent evt) {
+        public override void addAllowedPointer(PointerEvent evt) {
             startTrackingPointer(evt.pointer, evt.transform);
             _velocityTrackers[evt.pointer] = new VelocityTracker();
             if (_state == _ScaleState.ready) {

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

 
         protected abstract void handleTapCancel(PointerDownEvent down, PointerCancelEvent cancel, string reason);
 
-        public override void addAllowedPointer(PointerDownEvent evt) {
+        public override void addAllowedPointer(PointerEvent evt) {
+            var _evt = (PointerDownEvent) evt;
+            D.assert(_evt != null);
-                _down = evt;
+                _down = _evt;
-            base.addAllowedPointer(evt);
+            base.addAllowedPointer(_evt);
         }
 
         protected override void handlePrimaryPointer(PointerEvent evt) {

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

             RouteSettings routeSettings = null
         ) {
             D.assert(context != null);
-            D.assert(useRootNavigator != null);
             showDialog<object>(
                 context: context,
                 useRootNavigator: useRootNavigator,
             bool useRootNavigator = false
         ) {
             D.assert(context != null);
-            D.assert(useRootNavigator != null);
             Navigator.of(context, rootNavigator: useRootNavigator).push(new MaterialPageRoute(
                 builder: (BuildContext buildContext) => new LicensePage(
                     applicationName: applicationName,
         bool _loaded = false;
 
         Future _initLicenses() {
-            int debugFlowId = -1;
+            // int debugFlowId = -1;
             // D.assert(() => {
             //   Flow flow = Flow.begin();
             //   Timeline.timeSync("_initLicenses()", () { }, flow: flow);

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

 
             Widget title = widget.title;
             if (title != null) {
-                bool namesRoute;
-
                 switch (theme.platform) {
                     case RuntimePlatform.Android:
                     case RuntimePlatform.LinuxEditor:
-                        namesRoute = true;
-                        break;
-                    default:
                         break;
                 }
 

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

         }
 
         public static BottomSheetThemeData lerp(BottomSheetThemeData a, BottomSheetThemeData b, float t) {
-            D.assert(t != null);
             if (a == null && b == null)
                 return null;
             return new BottomSheetThemeData(

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

         }
 
         public Color getDisabledTextColor(MaterialButton button) {
-            if (button.textColor is MaterialStateProperty<Color>)
+            if (button.textColor is IMaterialStateProperty<Color>)
                 return button.textColor;
             if (button.disabledTextColor != null) {
                 return button.disabledTextColor;

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

 
                     if (table is RenderTable renderTable) {
                         TableCellParentData cellParentData = cell.parentData as TableCellParentData;
-                        D.assert(cellParentData.y != null);
                         Rect rect = renderTable.getRowBox(cellParentData.y);
                         // The rect is in the table's coordinate space. We need to change it to the
                         // TableRowInkWell's coordinate space.

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

 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
-using Unity.UIWidgets.service;
 using Unity.UIWidgets.ui;
 using Unity.UIWidgets.widgets;
 using UnityEngine;

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

         public override Color resolve(HashSet<MaterialState> states) => _resolve(states);
     }
 
-    abstract class MaterialStateProperty<T> {
+    interface IMaterialStateProperty<T> {
+        T resolve(HashSet<MaterialState> states);
+    }
+
+    abstract class MaterialStateProperty<T> : IMaterialStateProperty<T> {
-
 
         public static T resolveAs<T>(T value, HashSet<MaterialState> states) {
             if (value is MaterialStateProperty<T> materialStateProperty) {

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

         Color _outlineColor {
             get {
                 // TODO: what is the meaning of this line?
-                if (widget.borderSide?.color is MaterialStateProperty<Color>)
+                if (widget.borderSide?.color is IMaterialStateProperty<Color>)
                     return widget.borderSide.color;
                 if (!widget.enabled)
                     return widget.disabledBorderColor;

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

         }
 
         Widget _buildPicker() {
-            D.assert(_mode != null);
             switch (_mode) {
                 case DatePickerMode.day:
                     return new _MonthPicker(

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

                 selectableDayPredicate == null || selectableDayPredicate(initialDate),
                 () => $"Provided initialDate {initialDate} must satisfy provided selectableDayPredicate."
             );
-
-            D.assert(initialEntryMode != null);
-            D.assert(initialDatePickerMode != null);
+            
             D.assert(material_.debugCheckHasMaterialLocalizations(context));
 
             Widget dialog = new _DatePickerDialog(

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

             get { return _values; }
             set {
                 D.assert(value != null);
-                D.assert(value.start != null && value.start >= 0.0 && value.start <= 1.0f);
-                D.assert(value.end != null && value.end >= 0.0 && value.end <= 1.0f);
+                D.assert(value.start >= 0.0 && value.start <= 1.0f);
+                D.assert(value.end >= 0.0 && value.end <= 1.0f);
                 D.assert(value.start <= value.end);
 
                 RangeValues convertedValues = isDiscrete ? _discretizeRangeValues(value) : value;

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

         Color _bodyScrimColor = Colors.black;
 
         internal void showBodyScrim(bool value, float opacity) {
-            D.assert(value != null);
             if (_showBodyScrim == value && _bodyScrimColor.opacity == opacity) {
                 return;
             }

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

         const float _ninetyDegrees = Mathf.PI / 2.0f;
         const float _thirtyDegrees = Mathf.PI / 6.0f;
         const float _preferredHeight = _distanceBetweenTopBottomCenters + _topLobeRadius + _bottomLobeRadius;
-        const bool _debuggingLabelLocation = false;
+        static readonly bool _debuggingLabelLocation = false;
 
         public Size getPreferredSize(
             bool isEnabled,

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

 
         public override Widget build(BuildContext context) {
             D.assert(
-                !isSelected.Any((bool val) => val == null),
-                () => "All elements of isSelected must be non-null.\n" +
-                      "The current list of isSelected values is as follows:\n" +
-                      $"{isSelected}"
-            );
-            D.assert(
                 focusNodes == null || !focusNodes.Any((FocusNode val) => val == null),
                 () => "All elements of focusNodes must be non-null.\n" +
                       "The current list of focus node values is as follows:\n" +
             return box == null ? 0.0f : box.getMaxIntrinsicWidth(height);
         }
 
-        float computeDistanceToActualBaseline(TextBaseline baseline) {
+        public override float? computeDistanceToActualBaseline(TextBaseline baseline) {
             return child.computeDistanceToActualBaseline(baseline).Value +
                    horizontalBorderSide.width;
         }

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

         }
 
         public static AlignmentGeometry lerp(AlignmentGeometry a, AlignmentGeometry b, float t) {
-            D.assert(t != null);
             if (a == null && b == null)
                 return null;
             if (a == null)
         }
 
         public static AlignmentDirectional lerpAlignmentDirectional(AlignmentDirectional a, AlignmentDirectional b, float t) {
-            D.assert(t != null);
             if (a == null && b == null)
                 return null;
             if (a == null)
 
     public class TextAlignVertical {
         public TextAlignVertical(float y) {
-            D.assert(y != null);
             D.assert(y >= -1.0 && y <= 1.0);
             this.y = y;
         }

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

         public override ShapeBorder add(ShapeBorder other, bool reversed = false) => null;
 
         public static BoxBorder lerp(BoxBorder a, BoxBorder b, float t) {
-            D.assert(t != null);
             if ((a is Border || a == null) && (b is Border || b == null))
                 return Border.lerp((Border) a, (Border) b, t);
             if ((a is BorderDirectional || a == null) && (b is BorderDirectional || b == null))
         }
 
         public static BorderDirectional lerp(BorderDirectional a, BorderDirectional b, float t) {
-            D.assert(t != null);
             if (a == null && b == null)
                 return null;
             if (a == null)

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

         }
 
         static HSLColor lerp(HSLColor a, HSLColor b, float t) {
-            D.assert(t != null);
             if (a == null && b == null)
                 return null;
             if (a == null)
             style: style,
             level: level
         ) {
-            D.assert(showName != null);
-            D.assert(style != null);
-            D.assert(level != null);
         }
 
         public override Dictionary<string, object> toJsonMap(DiagnosticsSerializationDelegate Delegate) {

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

 
 
         float? along(Axis axis) {
-            D.assert(axis != null);
             switch (axis) {
                 case Axis.horizontal:
                     return horizontal;
-
             return null;
         }
 
         }
 
         public static EdgeInsetsGeometry lerp(EdgeInsetsGeometry a, EdgeInsetsGeometry b, float t) {
-            D.assert(t != null);
             if (a == null && b == null)
                 return null;
             if (a == null)
         }
 
         public static EdgeInsetsDirectional lerp(EdgeInsetsDirectional a, EdgeInsetsDirectional b, float t) {
-            D.assert(t != null);
             if (a == null && b == null)
                 return null;
             if (a == null)

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

 
     public abstract class ImageProvider {
         public abstract ImageStream resolve(ImageConfiguration configuration);
+        
+        public override bool Equals(object obj) {
+            if (ReferenceEquals(null, obj)) {
+                return false;
+            }
+
+            if (ReferenceEquals(this, obj)) {
+                return true;
+            }
+
+            if (obj.GetType() != GetType()) {
+                return false;
+            }
+
+            return false;
+        }
 
         public static bool operator ==(ImageProvider left, ImageProvider right) {
             return Equals(left, right);

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

 namespace Unity.UIWidgets.painting {
     abstract class PlaceholderSpan : InlineSpan {
         public PlaceholderSpan(
-            TextBaseline baseline = TextBaseline.alphabetic,
+            TextBaseline? baseline = null,
             TextStyle style = null,
             PlaceholderAlignment alignment = PlaceholderAlignment.bottom
             
 
         public PlaceholderAlignment alignment;
 
-        public TextBaseline baseline;
+        public TextBaseline? baseline;
 
         public override void computeToPlainText(
             StringBuilder buffer,

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

         public PlaceholderDimensions(
             Size size,
             PlaceholderAlignment alignment,
-            TextBaseline baseline,
+            TextBaseline? baseline,
-            D.assert(alignment != null);
             this.size = size;
             this.alignment = alignment;
             this.baseline = baseline;
 
         public readonly float baselineOffset;
 
-        public readonly TextBaseline baseline;
+        public readonly TextBaseline? baseline;
 
         public override string ToString() {
             return $"PlaceholderDimensions({size}, {baseline})";
         public TextWidthBasis textWidthBasis {
             get { return _textWidthBasis; }
             set {
-                D.assert(value != null);
                 if (_textWidthBasis == value)
                     return;
                 _textWidthBasis = value;
         }
 
         ParagraphStyle _createParagraphStyle(TextDirection defaultTextDirection = TextDirection.ltr) {
-            D.assert(textAlign != null);
             D.assert(textDirection != null,
                 () => "TextPainter.textDirection must be set to a non-null value before using the TextPainter.");
             return _text.style?.getParagraphStyle(

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

             return true;
         }
 
-        public float? getDistanceToBaseline(TextBaseline baseline, bool onlyReal = false) {
+        public float? getDistanceToBaseline(TextBaseline? baseline, bool onlyReal = false) {
             D.assert(!_debugDoingBaseline,
                 () =>
                     "Please see the documentation for computeDistanceToActualBaseline for the required calling conventions of this method.");
             return result;
         }
 
-        public virtual float? getDistanceToActualBaseline(TextBaseline baseline) {
+        public float? getDistanceToActualBaseline(TextBaseline? baseline) {
+            //If there is no baseline, return null by default
+            if (baseline == null) {
+                return null;
+            }
+            
-
+            
-            return _cachedBaselines.putIfAbsent(baseline, () => computeDistanceToActualBaseline(baseline));
+            return _cachedBaselines.putIfAbsent(baseline.Value, () => computeDistanceToActualBaseline(baseline.Value));
         }
 
         public virtual float? computeDistanceToActualBaseline(TextBaseline baseline) {

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

         Rect _caretPrototype;
 
         void _layoutText( float minWidth = 0.0f, float maxWidth = float.PositiveInfinity ) {
-            D.assert(maxWidth != null && minWidth != null);
             if (_textLayoutLastMaxWidth == maxWidth && _textLayoutLastMinWidth == minWidth)
                 return;
             float availableMaxWidth = Mathf.Max(0.0f, maxWidth - _caretMargin);
                         return Rect.fromLTWH(0.0f, EditableUtils._kCaretHeightOffset, cursorWidth,
                             preferredLineHeight - 2.0f * EditableUtils._kCaretHeightOffset);
                 }
-                return null;
             }
         }
 

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

                     context.canvas.drawParagraph(_paragraph, offset + new Offset(left, top));
                 }
             }
-            catch (Exception e) {
+            catch (Exception) {
                 // Intentionally left empty.
             }
         }

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

         
         public override string toStringShort() {
             string header = base.toStringShort();
-            if (_overflow is float && _hasOverflow)
+            if (_hasOverflow)
                 header += " OVERFLOWING";
             return header;
         }

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

         public Clip clipBehavior {
             get { return _clipBehavior; }
             set {
-                D.assert(value != null);
                 D.assert(value != Clip.none);
                 if (value != _clipBehavior) {
                     _clipBehavior = value;
         public Clip clipBehavior {
             get { return _clipBehavior; }
             set {
-                D.assert(value != null);
                 D.assert(value != Clip.none);
                 if (value != _clipBehavior) {
                     _clipBehavior = value;
             Path clipPath = null,
             Clip clipBehavior = Clip.antiAlias
         ) {
-            D.assert(clipBehavior != null);
             D.assert(clipBehavior != Clip.none);
             _clipPath = clipPath;
             _clipBehavior = clipBehavior;
         public Clip clipBehavior {
             get { return _clipBehavior; }
             set {
-                D.assert(value != null);
                 D.assert(value != Clip.none);
                 if (value != _clipBehavior) {
                     _clipBehavior = value;
         public int alpha {
             get { return _alpha; }
             set {
-                D.assert(value != null);
                 if (value != _alpha) {
                     _alpha = value;
                     markNeedsAddToScene();
 
         public override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
             layerOffset = layerOffset ?? Offset.zero;
-            D.assert(alpha != null);
             bool enabled = firstChild != null;
             D.assert(() => {
                 enabled = enabled && !D.debugDisableOpacityLayers;
         }
 
         public override void addToScene(SceneBuilder builder, Offset layerOffset = null) {
-            D.assert(optionsMask != null);
-
             layerOffset = layerOffset ?? Offset.zero;
             
             var shiftedOverlayRect = layerOffset == Offset.zero ? overlayRect : overlayRect.shift(layerOffset);

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

         public override string ToString() {
             List<string> values = new List<string>();
             if (offset != null) values.Add($"offset={offset}");
-            if (scale != null) values.Add($"scale={scale}");
+            values.Add($"scale={scale}");
             values.Add(base.ToString());
             return string.Join("; ", values);
         }

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

                     ((optionsMask | (1 << (int) PerformanceOverlayOption.visualizeEngineStatistics)) > 0))
                     result += kDefaultGraphHeight;
                 return result;
-
-                return result;
             }
         }
 

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

 
         public override int GetHashCode() {
             unchecked {
-                var hashCode = (width != null ? width.GetHashCode() : 0);
-                hashCode = (hashCode * 397) ^(height != null ? height.GetHashCode() : 0);
-                hashCode = (hashCode * 397) ^ (_ptr != null ? _ptr.GetHashCode() : 0);
+                var hashCode = (width.GetHashCode());
+                hashCode = (hashCode * 397) ^(height.GetHashCode());
+                hashCode = (hashCode * 397) ^ (_ptr.GetHashCode());
-
-    /*
-     * TODO: FrameInfo, Codec
-     */
 
     public delegate void ImageDecoderCallback(Image result);
 
         public virtual void drawPoints(PointMode pointMode, List<Offset> points, Paint paint) {
             unsafe
             {
-                D.assert(pointMode != null);
                 D.assert(points != null);
                 D.assert(paint != null);
                 float[] list = PaintingUtils._encodePointList(points);
         }
 
         public static Shadow lerp(Shadow a, Shadow b, float t) {
-            D.assert(t != null);
             if (a == null && b == null)
                 return null;
             if (a == null)
         }
 
         public static List<Shadow> lerpList(List<Shadow> a, List<Shadow> b, float t) {
-            D.assert(t != null);
             if (a == null && b == null)
                 return null;
             a = a ?? new List<Shadow>();

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

             bool shrinkWrap = false,
             EdgeInsetsGeometry padding = null) : base(key: key) { 
             D.assert(itemBuilder != null);
-            D.assert(initialItemCount != null && initialItemCount >= 0);
+            D.assert(initialItemCount >= 0);
             this.itemBuilder = itemBuilder;
             this.initialItemCount = initialItemCount;
             this.scrollDirection = scrollDirection;
 
         public static AnimatedListState of(BuildContext context,  bool nullOk = false ) { 
             D.assert(context != null);
-            D.assert(nullOk != null);
             AnimatedListState result = context.findAncestorStateOfType<AnimatedListState>();
             if (nullOk || result != null)
                 return result; 
 
 
         public static SliverAnimatedListState of(BuildContext context, bool nullOk = false) { 
-            D.assert(context != null); 
-            D.assert(nullOk != null);
+            D.assert(context != null);
             SliverAnimatedListState result = context.findAncestorStateOfType<SliverAnimatedListState>();
             if (nullOk || result != null)
                 return result;
         }
         public void insertItem(int index, TimeSpan? duration = null) { 
             duration = duration ?? _kDuration; 
-            D.assert(index != null && index >= 0);
-            D.assert(duration != null);
+            D.assert(index >= 0);
             int itemIndex = _indexToItemIndex(index);
             D.assert(itemIndex >= 0 && itemIndex <= _itemsCount);
 
         }
         public void removeItem(int index, AnimatedListRemovedItemBuilder builder, TimeSpan? duration = null) { 
             duration = duration ?? _kDuration; 
-            D.assert(index != null && index >= 0);
+            D.assert(index >= 0);
             D.assert(builder != null);
             D.assert(duration != null);
             int itemIndex = _indexToItemIndex(index);

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

 
         public static Dictionary<LogicalKeySet, Intent> defaultShortcuts {
             get {
+#pragma warning disable CS0162
+#pragma warning restore CS0162
 
                 switch (Application.platform) {
                     case RuntimePlatform.Android:

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

 //@immutable
     public class AsyncSnapshot<T> : IEquatable<AsyncSnapshot<T>> {
         AsyncSnapshot(ConnectionState connectionState, object data, object error) {
-            D.assert(connectionState != null);
             D.assert(!(data != null && error != null));
             this.connectionState = connectionState;
             this.data = (T) data;

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

             Widget child = null
         ) : base(key: key, child: child) {
             D.assert(shaderCallback != null);
-            D.assert(blendMode != null);
             this.shaderCallback = shaderCallback;
             this.blendMode = blendMode;
         }
             Clip clipBehavior = Clip.hardEdge,
             Widget child = null
         ) : base(key: key, child: child) {
-            D.assert(clipBehavior != null);
             this.clipper = clipper;
             this.clipBehavior = clipBehavior;
         }
             Clip clipBehavior = Clip.antiAlias,
             Widget child = null) : base(key: key, child: child
         ) {
-            D.assert(clipBehavior != null);
             this.clipper = clipper;
             this.clipBehavior = clipBehavior;
         }
             Clip clipBehavior = Clip.antiAlias,
             Widget child = null
         ) : base(key: key, child: child) {
-            D.assert(clipBehavior != null);
             this.clipper = clipper;
             this.clipBehavior = clipBehavior;
         }
             Widget child = null
         ) {
             D.assert(shape != null);
-            D.assert(clipBehavior != null);
             D.assert(clipBehavior != Clip.none);
             return new Builder(
                 key: key,
             Widget child = null) : base(key: key, child: child) {
             D.assert(color != null);
             D.assert(elevation >= 0.0f);
-            D.assert(clipBehavior != null);
             this.shape = shape;
             this.clipBehavior = clipBehavior;
             this.borderRadius = borderRadius;

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

                 () => "Cannot provide both a color and a decoration\n" +
                 "The color argument is just a shorthand for \"decoration: new BoxDecoration(color: color)\"."
             );
-            D.assert(clipBehavior != null);
-            
+
             this.alignment = alignment;
             this.padding = padding;
             this.foregroundDecoration = foregroundDecoration;

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

             }
         }
         public bool showToolbar() {
+#pragma warning disable CS0162
+#pragma warning restore CS0162
 
             if (_selectionOverlay == null || _selectionOverlay.toolbarIsVisible) {
                 return false;

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

             Widget result = _image(
                 image: image,
                 errorBuilder: imageErrorBuilder,
-                frameBuilder: (BuildContext context1, Widget child, int frame, bool wasSynchronouslyLoaded)=> {
+                frameBuilder: (BuildContext context1, Widget child, int? frame, bool wasSynchronouslyLoaded)=> {
                 if (wasSynchronouslyLoaded)
                     return child;
                 return new _AnimatedFadeOutFadeIn(
             }
 
             bool _isValid(Tween<float> tween) {
-                return tween.begin != null && tween.end != null;
+                return tween?.begin != null && tween?.end != null;
             }
 
 

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

 
         // Note that this is overridden in FocusScopeNode.
         public virtual void _doRequestFocus(bool findFirstFocus = false) {
-            D.assert(findFirstFocus != null);
             if (!canRequestFocus) {
                 D.assert(FocusManagerUtils._focusDebug(
                     $"Node NOT requesting focus because canRequestFocus is false: {this}"));

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

         }
     }
     class _FocusScopeState : _FocusState {
-        public FocusScopeNode _createNode() {
+        protected override FocusNode _createNode() {
             return new FocusScopeNode(
                 debugLabel: widget.debugLabel,
                 canRequestFocus: widget.canRequestFocus ?? true,
             _focusAttachment = focusNode.attach(context, onKey: widget.onKey);
             focusNode.addListener(_handleFocusChanged);
          }
-        public FocusNode _createNode() { 
+        protected virtual FocusNode _createNode() { 
             return new FocusNode(
             debugLabel: widget.debugLabel,
             canRequestFocus: widget.canRequestFocus ?? true,

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

         }
 
         public delegate int Comparator<T>(T a, T b);
-        //public Comparator<T> defaultCompare<T>() => (value1, value2) => value1 ;
+
+        static int defaultCompare<T>(T value1, T value2) {
+            return (value1 as IComparable).CompareTo(value2);
+        }
+        
-            int _start = start ?? 0;
-            int _end = end ?? list.Count;
-            compare = compare ;//?? <T>();
+            var _start = start ?? 0;
+            var _end = end ?? list.Count;
+            compare = compare ?? defaultCompare;
 
             int length = _end - _start;
             if (length < 2) return;
                 ); 
             return sortedDescendants; 
         }
-        protected bool _moveFocus(FocusNode currentNode,  bool forward = false) { 
-            D.assert(forward != null); 
+        protected bool _moveFocus(FocusNode currentNode,  bool forward = false) {
             if (currentNode == null) { 
                 return false; 
             } 
     }
     public class NumericFocusOrder : FocusOrder {
         public NumericFocusOrder(float order) {
-            D.assert(order != null);
             this.order = order;
         }
 

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

 
         internal Widget _widget;
         
-        public Widget widget {
+        public virtual Widget widget {
             get { return _widget; }
         }
         
         protected RenderObjectElement(RenderObjectWidget widget) : base(widget) {
         }
 
-        public new virtual RenderObjectWidget widget {
+        public new RenderObjectWidget widget {
             get { return (RenderObjectWidget) base.widget; }
         }
 

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

     public delegate Widget ImageFrameBuilder(
         BuildContext context,
         Widget child,
-        int frame,
+        int? frame,
         bool wasSynchronouslyLoaded
     );
 
             setState(() => {
                 _imageInfo = imageInfo;
                 _loadingProgress = null;
-                _frameNumber = _frameNumber == null ? 0 : _frameNumber + 1;
+                _frameNumber += 1;
                 _wasSynchronouslyLoaded |= synchronousCall;
             });
         }

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

             D.assert(perspective <= 0.01, () => RenderListWheelViewport.perspectiveTooHighMessage);
             D.assert(magnification > 0);
             D.assert(overAndUnderCenterOpacity >= 0 && overAndUnderCenterOpacity <= 1);
-            D.assert(itemExtent != null);
             D.assert(itemExtent > 0);
             D.assert(squeeze > 0);
             D.assert(

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

         public virtual object currentResult {
             get { return null; }
         }
-        public Future popped {
+        public virtual Future popped {
             get { return _popCompleter.future; }
         }
         protected internal virtual bool didPop(object result) {
         public Route(RouteSettings settings = null) {
             _settings = settings ?? new RouteSettings();
         }
-        public T currentResult {
+        public override object currentResult {
-        public Future<T> popped {
+        public override Future popped {
+        
         protected internal virtual bool didPop(T result) {
             didComplete(result);
             return true;

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

         public float page {
             get {
                 D.assert(
-                    pixels == null || (minScrollExtent != null && maxScrollExtent != null),
+                    !havePixels || (hasMinScrollExtent && hasMaxScrollExtent),
                     () => "Page value is only available after content dimensions are established."
                 );
                 return getPageFromPixels(pixels.clamp(minScrollExtent, maxScrollExtent),
             bool allowImplicitScrolling = false,
             ScrollPhysics parent = null
         ) : base(parent: parent) {
-            D.assert(allowImplicitScrolling != null);
             this.allowImplicitScrolling = allowImplicitScrolling;
         }
         
             );
         }
         
-        public readonly bool allowImplicitScrolling;
+        public override bool allowImplicitScrolling { get; }
     }
 
     public class PageScrollPhysics : ScrollPhysics {

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

     }
 
     public abstract class OverlayRoute<T> : OverlayRoute {
-        public readonly List<OverlayEntry> _overlayEntries = new List<OverlayEntry>();
+        
         protected internal new bool didPop(T result) {
             var returnValue = base.didPop(result);
             D.assert(returnValue);
             RouteTransitionsBuilder transitionBuilder = null,
             RouteSettings settings = null
             ) : base(settings: settings) {
-            D.assert(barrierDismissible != null);
             _pageBuilder = pageBuilder;
             _barrierLabel = barrierLabel;
             _barrierDismissible = barrierDismissible;

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

                     switch (state.axisDirection) {
                         case AxisDirection.up:
                             return -increment;
-                            break;
-                            break;
                         case AxisDirection.right:
                         case AxisDirection.left:
                             return 0.0f;
                     switch (state.axisDirection) {
                         case AxisDirection.up:
                             return increment;
-                            break;
-                            break;
                         case AxisDirection.right:
                         case AxisDirection.left:
                             return 0.0f;
                     switch (state.axisDirection) {
                         case AxisDirection.right:
                             return -increment;
-                            break;
-                            break;
                         case AxisDirection.up:
                         case AxisDirection.down:
                             return 0.0f;
                     switch (state.axisDirection) {
                         case AxisDirection.right:
                             return increment;
-                            break;
-                            break;
                         case AxisDirection.up:
                         case AxisDirection.down:
                             return 0.0f;
         public override void invoke(FocusNode node, Intent intent) {
             ScrollableState state = Scrollable.of(node.context);
             D.assert(state != null, () => "ScrollAction was invoked on a context that has no scrollable parent");
-            D.assert(state.position.pixels != null, () => "Scrollable must be laid out before it can be scrolled via a ScrollAction");
+            D.assert(state.position.havePixels, () => "Scrollable must be laid out before it can be scrolled via a ScrollAction");
             if (state.widget.physics != null && !state.widget.physics.shouldAcceptUserOffset(state.position)) {
                 return;
             }

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

             bool ignoring = true,
             Widget sliver = null
         ) : base(key: key, child: sliver) {
-            D.assert(ignoring != null);
             this.ignoring = ignoring;
 
         }
         Key key = null,
         bool offstage = true,
         Widget sliver = null) : base(key: key, child: sliver) {
-            D.assert(offstage != null);
             this.offstage = offstage;
         }
 

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

                     ((RenderObject)targetParent).markNeedsLayout();
             }
          }
-         Type debugTypicalAncestorWidgetClass {
+
+         public override Type debugTypicalAncestorWidgetClass {
              get { return typeof(Table);}
          }
 

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

                 return _handlesVisible;
             }
             set {
-                D.assert(value != null);
                 if (_handlesVisible == value)
                     return;
                 _handlesVisible = value;
         }
 
         public override Widget build(BuildContext context) {
-            List<TextSelectionPoint> endpoints =
-                widget.renderObject.getEndpointsForSelection(widget.selection);
-            Offset point = null;
-            
             LayerLink layerLink = null;
             TextSelectionHandleType type = TextSelectionHandleType.left;
 

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

             D.assert(offset != null);
             D.assert(slivers != null);
             D.assert(center == null || LinqUtils<Widget>.WhereList(slivers,((Widget child) => child.key == center)).Count() == 1);
-            D.assert(cacheExtentStyle != null);
             D.assert(cacheExtentStyle != CacheExtentStyle.viewport || cacheExtent != null);
             this.axisDirection = axisDirection;
             this.crossAxisDirection = crossAxisDirection;

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

             bool maintainInteractivity = false) : base (key: key) {
             replacementSliver = replacementSliver ?? new SliverToBoxAdapter();
             D.assert(sliver != null);
-            D.assert(visible != null);
-            D.assert(maintainState != null);
-            D.assert(maintainAnimation != null);
-            D.assert(maintainSize != null);
-            D.assert(maintainInteractivity != null);
             D.assert(
                 maintainState == true || maintainAnimation == false,
                 ()=>"Cannot maintain animations if the state is not also maintained."

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

 using TextStyle = Unity.UIWidgets.painting.TextStyle;
 
 namespace Unity.UIWidgets.widgets {
-    class WidgetSpan : PlaceholderSpan,IEquatable<WidgetSpan> {
+    class WidgetSpan : PlaceholderSpan, IEquatable<WidgetSpan> {
-            TextBaseline baseline = TextBaseline.alphabetic,
+            TextBaseline? baseline = null,
             TextStyle style = null,
             PlaceholderAlignment alignment = PlaceholderAlignment.bottom
         ) : base(