more fixes

com.unity.uiwidgets/Runtime/foundation/assertions.cs

         }
 
         protected override string valueToString(TextTreeConfiguration parentConfiguration = null) {
-            return string.Join("", value);
+            return string.Join("", valueT);
         }
     }
 

com.unity.uiwidgets/Runtime/foundation/diagnostics.cs

             }
 
             int startForLengthCalculations = -startOffset;
-            bool addPrefix = false;
             int index = 0;
             _WordWrapParseMode mode = _WordWrapParseMode.inSpace;
             int? lastWordStart = null;
                             if ((index - startForLengthCalculations <= width) || (lastWordEnd == null)) {
                                 lastWordEnd = index;
                             }
+                            string line = message.Substring(start, lastWordEnd.Value - start);
-                            string line = message.Substring(start, lastWordEnd.Value);
-                            addPrefix = true;
                             if (lastWordEnd.Value >= message.Length) {
                                 yield break;
                             }
 
         public readonly bool showSeparator;
 
-        public object value { get; }
+        public virtual object value { get; }
 
         public bool isFiltered(DiagnosticLevel minLevel) {
             return foundation_.kReleaseMode || level < minLevel;
 
         readonly DiagnosticsTreeStyle? _style;
 
-        public bool allowWrap {
+        public virtual bool allowWrap {
-        public bool allowNameWrap {
+        public virtual bool allowNameWrap {
-        public bool allowTruncate {
+        public virtual bool allowTruncate {
             get { return false; }
         }
 
         }
 
         protected override string valueToString(TextTreeConfiguration parentConfiguration = null) {
-            string text = _description ?? value;
+            string text = _description ?? valueT;
             if (parentConfiguration != null &&
                 !parentConfiguration.lineBreakProperties &&
                 text != null) {
 
         protected override string numberToString() {
             if (value != null) {
-                return value.Value.ToString("F1");
+                return valueT.Value.ToString("F1");
             }
 
             return "null";
                 return "null";
             }
 
-            return value.Value.ToString();
+            return valueT.Value.ToString();
         }
     }
 
                 return "null";
             }
 
-            return (value.Value.clamp(0.0f, 1.0f) * 100).ToString("F1") + "%";
+            return (valueT.Value.clamp(0.0f, 1.0f) * 100).ToString("F1") + "%";
         }
     }
 
         public readonly string ifFalse;
 
         protected override string valueToString(TextTreeConfiguration parentConfiguration = null) {
-            if (value == true) {
+            if (valueT == true) {
-            else if (value == false) {
+            else if (valueT == false) {
                 if (ifFalse != null) {
                     return ifFalse;
                 }
 
         public override bool showName {
             get {
-                if (value == null || value == true && ifTrue == null ||
-                    value == false && ifFalse == null) {
+                if (value == null || valueT == true && ifTrue == null ||
+                    valueT == false && ifFalse == null) {
                     return true;
                 }
 
 
         public override DiagnosticLevel level {
             get {
-                if (value == true) {
+                if (valueT == true) {
-                if (value == false) {
+                if (valueT == false) {
                     if (ifFalse == null) {
                         return DiagnosticLevel.hidden;
                     }
                 return "null";
             }
 
-            if (!value.Any()) {
+            if (!valueT.Any()) {
-               return string.Join(", ", LinqUtils<string, T>.SelectList(value, (v => v.ToString())));
+               return string.Join(", ", LinqUtils<string, T>.SelectList(valueT, (v => v.ToString())));
-                LinqUtils<string, T>.SelectList(value,  (v => v.ToString())));
+                LinqUtils<string, T>.SelectList(valueT,  (v => v.ToString())));
-                    value != null && !value.Any()
+                    value != null && !valueT.Any()
                     && base.level != DiagnosticLevel.hidden) {
                     return DiagnosticLevel.fine;
                 }
         public override Dictionary<string, object> toJsonMap(DiagnosticsSerializationDelegate Delegate) {
             var json = base.toJsonMap(Delegate);
             if (value != null) {
-                json["values"] = LinqUtils<string, T>.SelectList(value, (v => v.ToString()));
+                json["values"] = LinqUtils<string, T>.SelectList(valueT, (v => v.ToString()));
             }
 
             return json;
 
         public override Dictionary<string, object> toJsonMap(DiagnosticsSerializationDelegate Delegate) {
             Dictionary<string, object> json = base.toJsonMap(Delegate);
-            if (value.isNotEmpty()) {
+            if (valueT.isNotEmpty()) {
                 json["values"] = _formattedValues().ToList();
             }
 
         bool _hasNonNullEntry() {
-            return value.Values.ToList().Any((T o) => o != null);
+            return valueT.Values.ToList().Any((T o) => o != null);
-            foreach (string entry in value.Keys) {
-                if (value[entry] != null) {
+            foreach (string entry in valueT.Keys) {
+                if (valueT[entry] != null) {
                     results.Add(entry);
                 }
             }
 
         public readonly bool expandableValue;
 
-        public readonly bool allowWrap;
+        public override bool allowWrap { get; }
-        public readonly bool allowNameWrap;
+        public override bool allowNameWrap { get; }
-            T v = value;
+            T v = valueT;
             List<Dictionary<string, object>> properties = new List<Dictionary<string, object>>();
             if (Delegate.expandPropertyValues && Delegate.includeProperties && v is Diagnosticable vDiagnosticable &&
                 getProperties().isEmpty()) {
             get { return value; }
         }
 
-        public T value {
+        public override object value {
+            }
+        }
+
+        public T valueT {
+            get {
+                return (T) value;
             }
         }
 
 
         public override List<DiagnosticsNode> getProperties() {
             if (expandableValue) {
-                T obj = value;
+                T obj = valueT;
                 if (obj is DiagnosticsNode) {
                     return (obj as DiagnosticsNode).getProperties();
                 }
 
         public override List<DiagnosticsNode> getChildren() {
             if (expandableValue) {
-                T obj = value;
+                T obj = valueT;
                 if (obj is DiagnosticsNode) {
                     return (obj as DiagnosticsNode).getChildren();
                 }
             get { return value; }
         }
 
-        public T value {
+        public override object value {
+        }
+
+        public T valueT {
+            get { return (T) value; }
         }
 
         readonly T _value;
 
         public override List<DiagnosticsNode> getChildren() {
             if (value != null) {
-                return value.debugDescribeChildren();
+                return valueT.debugDescribeChildren();
             }
 
             return new List<DiagnosticsNode>();
 
         public override object valueObject { get; }
 
-        public readonly bool allowTruncate;
+        public override bool allowTruncate { get; }
 
         public override List<DiagnosticsNode> getChildren() {
             return _children;
 
         public abstract DiagnosticsSerializationDelegate delegateForNode(DiagnosticsNode node);
 
-        public int subtreeDepth { get; }
+        public virtual int subtreeDepth { get; }
-        public bool includeProperties { get; }
+        public virtual bool includeProperties { get; }
-        public bool expandPropertyValues { get; }
+        public virtual bool expandPropertyValues { get; }
 
         public abstract DiagnosticsSerializationDelegate copyWith(
             int? subtreeDepth = null,
             return subtreeDepth > 0 ? copyWith(subtreeDepth: subtreeDepth - 1) : this;
         }
 
-        new bool expandPropertyValues {
+        public override bool expandPropertyValues {
             get { return false; }
         }
 
             return nodes;
         }
 
-        public new readonly bool includeProperties;
+        public override bool includeProperties { get; }
-        public new readonly int subtreeDepth;
+        public override int subtreeDepth { get; }
 
         public override List<DiagnosticsNode> truncateNodesList(List<DiagnosticsNode> nodes, DiagnosticsNode owner) {
             return nodes;

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

         }
 
 
-        public readonly string barrierLabel;
+        public override string barrierLabel { get; }
 
         public override Color barrierColor {
             get { return modalBarrierColor ?? Colors.black54; }

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

         }
 
         public override Widget build(BuildContext context) {
-            Color effectiveTextColor = MaterialStateProperty<Color>.resolveAs<Color>(widget.textStyle?.color, _states);
-            ShapeBorder effectiveShape = MaterialStateProperty<Color>.resolveAs<ShapeBorder>(widget.shape, _states);
+            Color effectiveTextColor = MaterialStateProperty<Color>.resolveAsMaterialStateProperty<Color>(widget.textStyle?.color, _states);
+            ShapeBorder effectiveShape = MaterialStateProperty<Color>.resolveAsMaterialStateProperty<ShapeBorder>(widget.shape, _states);
             Offset densityAdjustment = widget.visualDensity.baseSizeAdjustment;
             BoxConstraints effectiveConstraints = widget.visualDensity.effectiveConstraints(widget.constraints);
             EdgeInsetsGeometry padding = widget.padding.add(
                     right: densityAdjustment.dx,
                     bottom: densityAdjustment.dy
                 )
-            ).clamp(EdgeInsets.zero, EdgeInsetsGeometry.infinity) as EdgeInsets;
+            ).clamp(EdgeInsets.zero, EdgeInsetsGeometry.infinityEdgeInsetsGeometry) as EdgeInsets;
 
             Widget result = new ConstrainedBox(
                 constraints: effectiveConstraints,

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

             bool showCheckmark = widget.showCheckmark ?? chipTheme.showCheckmark ?? true;
 
             TextStyle effectiveLabelStyle = widget.labelStyle ?? chipTheme.labelStyle;
-            Color resolvedLabelColor = MaterialStateProperty<Color>.resolveAs(effectiveLabelStyle?.color, _states);
+            Color resolvedLabelColor = MaterialStateProperty<Color>.resolveAsMaterialStateProperty(effectiveLabelStyle?.color, _states);
             TextStyle resolvedLabelStyle = effectiveLabelStyle?.copyWith(color: resolvedLabelColor);
 
             Widget result = new Material(

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

             get { return null; }
         }
 
-        public string barrierLabel;
+        public override string barrierLabel { get; }
 
         public override Widget buildPage(BuildContext context, Animation<float> animation,
             Animation<float> secondaryAnimation) {

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

     abstract class MaterialStateProperty<T> : IMaterialStateProperty<T> {
         public abstract T resolve(HashSet<MaterialState> states);
 
-        public static S resolveAs<S>(S value, HashSet<MaterialState> states) {
+        public static S resolveAsMaterialStateProperty<S>(S value, HashSet<MaterialState> states) {
             if (value is MaterialStateProperty<S> materialStateProperty) {
                 MaterialStateProperty<S> property = materialStateProperty;
                 return property.resolve(states);
         }
 
-        public static MaterialStateProperty<S> resolveWith<S>(material_.MaterialPropertyResolver<S> callback) =>
+        public static MaterialStateProperty<S> resolveWithMaterialStateProperty<S>(material_.MaterialPropertyResolver<S> callback) =>
             new _MaterialStateProperty<S>(callback);
     }
 
 
         public override T resolve(HashSet<MaterialState> states) => _resolve(states);
 
-        public static S resolveAs<S>(S value, HashSet<MaterialState> states) {
+        public static S resolveAs_MaterialStateProperty<S>(S value, HashSet<MaterialState> states) {
-
-        public static MaterialStateProperty<S> resolveWith<S>(material_.MaterialPropertyResolver<S> callback) =>
+        public static MaterialStateProperty<S> resolveWith_MaterialStateProperty<S>(material_.MaterialPropertyResolver<S> callback) =>
             new _MaterialStateProperty<S>(callback);
     }
 }

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

         public ShapeBorder resolve(HashSet<MaterialState> states) {
             return new _OutlineBorder(
                 shape: shape,
-                side: side.copyWith(color: MaterialStateProperty<Color>.resolveAs(side.color, states)
+                side: side.copyWith(color: MaterialStateProperty<Color>.resolveAsMaterialStateProperty(side.color, states)
                 )
             );
         }

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

-using System;
-using Unity.UIWidgets.animation;
-using Unity.UIWidgets.async;
 using Unity.UIWidgets.cupertino;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using TextStyle = Unity.UIWidgets.painting.TextStyle;
 
 namespace Unity.UIWidgets.material {
-
     public static class SelectableTextUtils {
         internal const int iOSHorizontalOffset = -2;
     }
             D.assert(textSpan != null);
             _textSpan = textSpan;
         }
-        
+
-        public override TextSpan buildTextSpan(TextStyle style = null ,bool withComposing = false) {
+        public override TextSpan buildTextSpan(TextStyle style = null, bool withComposing = false) {
-        
+
-            set {
-                
-            }
+            set { }
         }
     }
 
         ) : base(_delegate: state) {
             _state = state;
         }
-        
+
         public readonly _SelectableTextState _state;
 
         protected override void onForcePressStart(ForcePressDetails details) {
         protected override void onSingleLongTapMoveUpdate(LongPressMoveUpdateDetails details) {
             if (_delegate.selectionEnabled) {
                 switch (Theme.of(_state.context).platform) {
-                    case RuntimePlatform.IPhonePlayer: 
+                    case RuntimePlatform.IPhonePlayer:
                     case RuntimePlatform.OSXEditor:
                     case RuntimePlatform.OSXPlayer:
                         renderEditable.selectPositionAt(
             editableText.hideToolbar();
             if (_delegate.selectionEnabled) {
                 switch (Theme.of(_state.context).platform) {
-                    case RuntimePlatform.IPhonePlayer: 
+                    case RuntimePlatform.IPhonePlayer:
                     case RuntimePlatform.OSXEditor:
                     case RuntimePlatform.OSXPlayer:
                         renderEditable.selectWordEdge(cause: SelectionChangedCause.tap);
                         break;
                 }
             }
+
             if (_state.widget.onTap != null)
                 _state.widget.onTap();
         }
                 switch (Theme.of(_state.context).platform) {
-                    case RuntimePlatform.IPhonePlayer: 
+                    case RuntimePlatform.IPhonePlayer:
                     case RuntimePlatform.OSXEditor:
                     case RuntimePlatform.OSXPlayer:
                         renderEditable.selectPositionAt(
     }
 
     public class SelectableText : StatefulWidget {
-
         public SelectableText(
             string data,
             Key key = null,
             GestureTapCallback onTap = null,
             ScrollPhysics scrollPhysics = null,
             TextWidthBasis? textWidthBasis = null
-            ) : this(
+        ) : this(
             data: data,
             textSpan: null,
             key: key,
             onTap: onTap,
             scrollPhysics: scrollPhysics,
             textWidthBasis: textWidthBasis
-            ) {
+        ) {
-        
+
         SelectableText(
             string data,
             TextSpan textSpan,
             GestureTapCallback onTap = null,
             ScrollPhysics scrollPhysics = null,
             TextWidthBasis? textWidthBasis = null
-            ) : base(key: key) {
+        ) : base(key: key) {
             D.assert(maxLines == null || maxLines > 0);
             D.assert(minLines == null || minLines > 0);
             D.assert(
                                  selectAll: true,
                                  copy: true
                              );
-            
+
             this.data = data;
             this.textSpan = textSpan;
             this.focusNode = focusNode;
                 textSpan != null,
                 () => "A non-null TextSpan must be provided to a SelectableText.rich widget."
             );
-            
+
             return new SelectableText(
                 data: null,
                 textSpan: textSpan,
                 onTap: onTap,
                 scrollPhysics: scrollPhysics,
                 textWidthBasis: textWidthBasis
-                );
+            );
-  
-  public readonly string data; 
+
+        public readonly string data;
+
+        public readonly TextSpan textSpan;
+
+        public readonly FocusNode focusNode;
-  public readonly TextSpan textSpan;
+        public readonly TextStyle style;
+
+        public readonly StrutStyle strutStyle;
-  public readonly FocusNode focusNode;
+        public readonly TextAlign? textAlign;
-  public readonly TextStyle style;
+        public readonly TextDirection? textDirection;
-  public readonly StrutStyle strutStyle;
+        public readonly float? textScaleFactor;
+
+
+        public readonly bool autofocus;
+
+
+        public readonly int? minLines;
+
+
+        public readonly int? maxLines;
+
-  public readonly TextAlign? textAlign;
+        public readonly bool showCursor;
-  public readonly TextDirection? textDirection;
-  public readonly float? textScaleFactor;
+        public readonly float cursorWidth;
-  
-  public readonly bool autofocus;
-  
-  public readonly int? minLines;
+        public readonly Radius cursorRadius;
-  
-  public readonly int? maxLines;
+        public readonly Color cursorColor;
-  
-  public readonly bool showCursor;
-  
-  public readonly float cursorWidth;
+        public readonly bool enableInteractiveSelection;
-  
-  public readonly Radius cursorRadius;
-  public readonly Color cursorColor;
+        public readonly DragStartBehavior dragStartBehavior;
-  
-  public readonly bool enableInteractiveSelection;
+        public readonly ToolbarOptions toolbarOptions;
-  
-  public readonly DragStartBehavior dragStartBehavior;
-  public readonly ToolbarOptions toolbarOptions;
+        internal bool selectionEnabled {
+            get { return enableInteractiveSelection; }
+        }
+        public readonly GestureTapCallback onTap;
-  internal bool  selectionEnabled {
-      get { return enableInteractiveSelection; }
-  }
-  public readonly GestureTapCallback onTap;
+        public readonly ScrollPhysics scrollPhysics;
-  
-  public readonly ScrollPhysics scrollPhysics;
-  
-  public readonly TextWidthBasis? textWidthBasis;
+        public readonly TextWidthBasis? textWidthBasis;
-  public override State createState() => new _SelectableTextState();
+        public override State createState() => new _SelectableTextState();
-  public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
-      base.debugFillProperties(properties);
-      properties.add( new DiagnosticsProperty<string>("data", data, defaultValue: null));
-      properties.add( new DiagnosticsProperty<FocusNode>("focusNode", focusNode, defaultValue: null));
-      properties.add( new DiagnosticsProperty<TextStyle>("style", style, defaultValue: null));
-      properties.add( new DiagnosticsProperty<bool>("autofocus", autofocus, defaultValue: false));
-      properties.add( new DiagnosticsProperty<bool>("showCursor", showCursor, defaultValue: false));
-      properties.add( new IntProperty("minLines", minLines, defaultValue: null));
-      properties.add( new IntProperty("maxLines", maxLines, defaultValue: null));
-      properties.add( new EnumProperty<TextAlign?>("textAlign", textAlign, defaultValue: null));
-      properties.add( new EnumProperty<TextDirection?>("textDirection", textDirection, defaultValue: null));
-      properties.add( new FloatProperty("textScaleFactor", textScaleFactor, defaultValue: null));
-      properties.add( new FloatProperty("cursorWidth", cursorWidth, defaultValue: 2.0f));
-      properties.add( new DiagnosticsProperty<Radius>("cursorRadius", cursorRadius, defaultValue: null));
-      properties.add( new DiagnosticsProperty<Color>("cursorColor", cursorColor, defaultValue: null));
-      properties.add( new FlagProperty("selectionEnabled", value: selectionEnabled, defaultValue: true, ifFalse: "selection disabled"));
-      properties.add( new DiagnosticsProperty<ScrollPhysics>("scrollPhysics", scrollPhysics, defaultValue: null));
-  }
+        public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+            base.debugFillProperties(properties);
+            properties.add(new DiagnosticsProperty<string>("data", data, defaultValue: null));
+            properties.add(new DiagnosticsProperty<FocusNode>("focusNode", focusNode, defaultValue: null));
+            properties.add(new DiagnosticsProperty<TextStyle>("style", style, defaultValue: null));
+            properties.add(new DiagnosticsProperty<bool>("autofocus", autofocus, defaultValue: false));
+            properties.add(new DiagnosticsProperty<bool>("showCursor", showCursor, defaultValue: false));
+            properties.add(new IntProperty("minLines", minLines, defaultValue: null));
+            properties.add(new IntProperty("maxLines", maxLines, defaultValue: null));
+            properties.add(new EnumProperty<TextAlign?>("textAlign", textAlign, defaultValue: null));
+            properties.add(new EnumProperty<TextDirection?>("textDirection", textDirection, defaultValue: null));
+            properties.add(new FloatProperty("textScaleFactor", textScaleFactor, defaultValue: null));
+            properties.add(new FloatProperty("cursorWidth", cursorWidth, defaultValue: 2.0f));
+            properties.add(new DiagnosticsProperty<Radius>("cursorRadius", cursorRadius, defaultValue: null));
+            properties.add(new DiagnosticsProperty<Color>("cursorColor", cursorColor, defaultValue: null));
+            properties.add(new FlagProperty("selectionEnabled", value: selectionEnabled, defaultValue: true,
+                ifFalse: "selection disabled"));
+            properties.add(new DiagnosticsProperty<ScrollPhysics>("scrollPhysics", scrollPhysics, defaultValue: null));
+        }
-        
-        
+
         _TextSpanEditingController _controller;
 
         FocusNode _focusNode;
             get { return _forcePressEnabled; }
             set { _forcePressEnabled = value; }
         }
-        
+
         bool _forcePressEnabled;
 
         public GlobalKey<EditableTextState> editableTextKey {
                     textSpan: widget.textSpan ?? new TextSpan(text: widget.data)
                 );
             }
+
             if (_effectiveFocusNode.hasFocus && _controller.selection.isCollapsed) {
                 _showSelectionHandles = false;
             }
             _focusNode?.dispose();
             base.dispose();
         }
-        
+
-                setState(() => {
-                    _showSelectionHandles = willShowSelectionHandles;
-                });
+                setState(() => { _showSelectionHandles = willShowSelectionHandles; });
             }
 
             switch (Theme.of(context).platform) {
                     if (cause == SelectionChangedCause.longPress) {
                         _editableText?.bringIntoView(selection.basePos);
                     }
+
-                // Do nothing.
-                break;
+                    // Do nothing.
+                    break;
-        
+
-        
+
         bool _shouldShowSelectionHandles(SelectionChangedCause cause) {
             if (!_selectionGestureDetectorBuilder.shouldShowSelectionToolbar)
                 return false;
         }
 
         protected override bool wantKeepAlive => true;
-        
-        Widget build(BuildContext context) {
-    base.build(context);
-    D.assert(() => {
-      return _controller._textSpan.visitChildren((InlineSpan span) => span is TextSpan);
-    }, () => "SelectableText only supports TextSpan; Other type of InlineSpan is not allowed");
-    D.assert(WidgetsD.debugCheckHasMediaQuery(context));
-    D.assert(WidgetsD.debugCheckHasDirectionality(context));
-    D.assert(
-      !(widget.style != null && widget.style.inherit == false &&
-          (widget.style.fontSize == null || widget.style.textBaseline == null)),
-      () => "inherit false style must supply fontSize and textBaseline"
-    );
+
+        public override Widget build(BuildContext context) {
+            base.build(context);
+            D.assert(() => { return _controller._textSpan.visitChildren((InlineSpan span) => span is TextSpan); },
+                () => "SelectableText only supports TextSpan; Other type of InlineSpan is not allowed");
+            D.assert(WidgetsD.debugCheckHasMediaQuery(context));
+            D.assert(WidgetsD.debugCheckHasDirectionality(context));
+            D.assert(
+                !(widget.style != null && widget.style.inherit == false &&
+                  (widget.style.fontSize == null || widget.style.textBaseline == null)),
+                () => "inherit false style must supply fontSize and textBaseline"
+            );
-     ThemeData themeData = Theme.of(context);
-     FocusNode focusNode = _effectiveFocusNode;
+            ThemeData themeData = Theme.of(context);
+            FocusNode focusNode = _effectiveFocusNode;
-    TextSelectionControls textSelectionControls;
-    bool paintCursorAboveText;
-    bool cursorOpacityAnimates;
-    Offset cursorOffset = Offset.zero;
-    Color cursorColor = widget.cursorColor;
-    Radius cursorRadius = widget.cursorRadius;
+            TextSelectionControls textSelectionControls;
+            bool paintCursorAboveText;
+            bool cursorOpacityAnimates;
+            Offset cursorOffset = Offset.zero;
+            Color cursorColor = widget.cursorColor;
+            Radius cursorRadius = widget.cursorRadius;
-    switch (themeData.platform) {
-        case RuntimePlatform.IPhonePlayer:
-        case RuntimePlatform.OSXEditor:
-        case RuntimePlatform.OSXPlayer:
-            forcePressEnabled = true;
-            textSelectionControls = CupertinoTextFieldUtils.cupertinoTextSelectionControls;
-            paintCursorAboveText = true;
-            cursorOpacityAnimates = true;
-            cursorColor = cursorColor ?? CupertinoTheme.of(context).primaryColor;
-            cursorRadius = cursorRadius?? Radius.circular(2.0f);
-            cursorOffset = new Offset(SelectableTextUtils.iOSHorizontalOffset / MediaQuery.of(context).devicePixelRatio, 0);
-            break;
+            switch (themeData.platform) {
+                case RuntimePlatform.IPhonePlayer:
+                case RuntimePlatform.OSXEditor:
+                case RuntimePlatform.OSXPlayer:
+                    forcePressEnabled = true;
+                    textSelectionControls = CupertinoTextFieldUtils.cupertinoTextSelectionControls;
+                    paintCursorAboveText = true;
+                    cursorOpacityAnimates = true;
+                    cursorColor = cursorColor ?? CupertinoTheme.of(context).primaryColor;
+                    cursorRadius = cursorRadius ?? Radius.circular(2.0f);
+                    cursorOffset =
+                        new Offset(SelectableTextUtils.iOSHorizontalOffset / MediaQuery.of(context).devicePixelRatio,
+                            0);
+                    break;
-        default:
-            forcePressEnabled = false;
-            textSelectionControls = _MaterialTextSelectionControls.materialTextSelectionControls;
-            paintCursorAboveText = false;
-            cursorOpacityAnimates = false;
-            cursorColor = cursorColor ?? themeData.cursorColor;
-            break;
-    }
+                default:
+                    forcePressEnabled = false;
+                    textSelectionControls = _MaterialTextSelectionControls.materialTextSelectionControls;
+                    paintCursorAboveText = false;
+                    cursorOpacityAnimates = false;
+                    cursorColor = cursorColor ?? themeData.cursorColor;
+                    break;
+            }
-    DefaultTextStyle defaultTextStyle = DefaultTextStyle.of(context);
-    TextStyle effectiveTextStyle = widget.style;
-    if (widget.style == null || widget.style.inherit)
-      effectiveTextStyle = defaultTextStyle.style.merge(widget.style);
-    if (MediaQuery.boldTextOverride(context))
-      effectiveTextStyle = effectiveTextStyle.merge(new TextStyle(fontWeight: FontWeight.bold));
-    
-    Widget child = new RepaintBoundary(
-      child: new EditableText(
-        key: editableTextKey,
-        style: effectiveTextStyle,
-        readOnly: true,
-        textWidthBasis: widget.textWidthBasis ?? defaultTextStyle.textWidthBasis,
-        showSelectionHandles: _showSelectionHandles,
-        showCursor: widget.showCursor,
-        controller: _controller,
-        focusNode: focusNode,
-        strutStyle: widget.strutStyle ?? new StrutStyle(),
-        textAlign: widget.textAlign ?? defaultTextStyle.textAlign ?? TextAlign.start,
-        textDirection: widget.textDirection,
-        textScaleFactor: widget.textScaleFactor,
-        autofocus: widget.autofocus,
-        forceLine: false,
-        toolbarOptions: widget.toolbarOptions,
-        minLines: widget.minLines,
-        maxLines: widget.maxLines ?? defaultTextStyle.maxLines,
-        selectionColor: themeData.textSelectionColor,
-        selectionControls: widget.selectionEnabled ? textSelectionControls : null,
-        onSelectionChanged: _handleSelectionChanged,
-        onSelectionHandleTapped: _handleSelectionHandleTapped,
-        rendererIgnoresPointer: true,
-        cursorWidth: widget.cursorWidth,
-        cursorRadius: cursorRadius,
-        cursorColor: cursorColor,
-        cursorOpacityAnimates: cursorOpacityAnimates,
-        cursorOffset: cursorOffset,
-        paintCursorAboveText: paintCursorAboveText,
-        backgroundCursorColor: CupertinoColors.inactiveGray,
-        enableInteractiveSelection: widget.enableInteractiveSelection,
-        dragStartBehavior: widget.dragStartBehavior,
-        scrollPhysics: widget.scrollPhysics
-      )
-    );
+            DefaultTextStyle defaultTextStyle = DefaultTextStyle.of(context);
+            TextStyle effectiveTextStyle = widget.style;
+            if (widget.style == null || widget.style.inherit)
+                effectiveTextStyle = defaultTextStyle.style.merge(widget.style);
+            if (MediaQuery.boldTextOverride(context))
+                effectiveTextStyle = effectiveTextStyle.merge(new TextStyle(fontWeight: FontWeight.bold));
-    return _selectionGestureDetectorBuilder.buildGestureDetector(
-        behavior: HitTestBehavior.translucent,
-        child: child
-    );
+            Widget child = new RepaintBoundary(
+                child: new EditableText(
+                    key: editableTextKey,
+                    style: effectiveTextStyle,
+                    readOnly: true,
+                    textWidthBasis: widget.textWidthBasis ?? defaultTextStyle.textWidthBasis,
+                    showSelectionHandles: _showSelectionHandles,
+                    showCursor: widget.showCursor,
+                    controller: _controller,
+                    focusNode: focusNode,
+                    strutStyle: widget.strutStyle ?? new StrutStyle(),
+                    textAlign: widget.textAlign ?? defaultTextStyle.textAlign ?? TextAlign.start,
+                    textDirection: widget.textDirection,
+                    textScaleFactor: widget.textScaleFactor,
+                    autofocus: widget.autofocus,
+                    forceLine: false,
+                    toolbarOptions: widget.toolbarOptions,
+                    minLines: widget.minLines,
+                    maxLines: widget.maxLines ?? defaultTextStyle.maxLines,
+                    selectionColor: themeData.textSelectionColor,
+                    selectionControls: widget.selectionEnabled ? textSelectionControls : null,
+                    onSelectionChanged: _handleSelectionChanged,
+                    onSelectionHandleTapped: _handleSelectionHandleTapped,
+                    rendererIgnoresPointer: true,
+                    cursorWidth: widget.cursorWidth,
+                    cursorRadius: cursorRadius,
+                    cursorColor: cursorColor,
+                    cursorOpacityAnimates: cursorOpacityAnimates,
+                    cursorOffset: cursorOffset,
+                    paintCursorAboveText: paintCursorAboveText,
+                    backgroundCursorColor: CupertinoColors.inactiveGray,
+                    enableInteractiveSelection: widget.enableInteractiveSelection,
+                    dragStartBehavior: widget.dragStartBehavior,
+                    scrollPhysics: widget.scrollPhysics
+                )
+            );
+
+            return _selectionGestureDetectorBuilder.buildGestureDetector(
+                behavior: HitTestBehavior.translucent,
+                child: child
+            );
         }
     }
 }

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

             }
         }
 
+#pragma warning disable CS0108
+#pragma warning restore CS0108
 
         public static ShaderWarmUp shaderWarmUp = new DefaultShaderWarmUp();
 

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

             Dictionary<string, object> json = base.toJsonMap(Delegate);
             if (value != null) {
                 json["valueProperties"] = new Dictionary<string, object> {
-                    {"red", value.red},
-                    {"green", value.green},
-                    {"blue", value.blue},
-                    {"alpha", value.alpha}
+                    {"red", valueT.red},
+                    {"green", valueT.green},
+                    {"blue", valueT.blue},
+                    {"alpha", valueT.alpha}
                 };
             }
 

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

         internal virtual float _top { get; }
 
 
-        public static EdgeInsetsGeometry infinity = _MixedEdgeInsets.fromLRSETB(
+        public static EdgeInsetsGeometry infinityEdgeInsetsGeometry = _MixedEdgeInsets.fromLRSETB(
             float.PositiveInfinity,
             float.PositiveInfinity,
             float.PositiveInfinity,
         }
 
 
-        public float horizontal {
+        public virtual float horizontal {
-        public float vertical {
+        public virtual float vertical {
             get { return _top + _bottom; }
         }
 
             return new _MixedEdgeInsets(_left, _right, _start, _end, _top, _bottom);
         }
 
-        public readonly float _left;
+        internal override float _left { get; }
-        public readonly float _right;
+        internal override float _right { get; }
-        public readonly float _start;
+        internal override float _start { get; }
-        public readonly float _end;
+        internal override float _end { get; }
-        public readonly float _top;
+        internal override float _top { get; }
-        public readonly float _bottom;
+        internal override float _bottom { get; }
 
 
         public override bool isNonNegative {
         public readonly float top;
         public readonly float bottom;
 
-        public static EdgeInsets infinity = fromLTRB(
+        public static EdgeInsets infinityEdgeInsets = fromLTRB(
             float.PositiveInfinity,
             float.PositiveInfinity,
             float.PositiveInfinity,
-        public bool isNonNegative {
+        public override bool isNonNegative {
             get {
                 return left >= 0.0
                        && right >= 0.0
         }
 
-        public float horizontal {
+        public override float horizontal {
-        public float vertical {
+        public override float vertical {
             get { return top + bottom; }
         }
 

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

             return false;
         }
 
+        public override int GetHashCode() {
+            return base.GetHashCode();
+        }
+
         public static bool operator ==(ImageProvider left, ImageProvider right) {
             return Equals(left, right);
         }

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

         public virtual bool debugAssertIsValid() => true;
         public abstract RenderComparison compareTo(InlineSpan other);
 
-        public virtual void debugFillProperties(DiagnosticPropertiesBuilder properties) {
+        public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             base.debugFillProperties(properties);
             properties.defaultDiagnosticsTreeStyle = DiagnosticsTreeStyle.whitespace;
             if (style != null) {

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

                 return value == null ? "null" : value.ToString();
             }
 
-            return string.Join("\n", MatrixUtils.debugDescribeTransform(value));
+            return string.Join("\n", MatrixUtils.debugDescribeTransform(valueT));
         }
     }
 }

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

 
 namespace Unity.UIWidgets.rendering {
     public class RendererBinding : SchedulerBinding {
+        
+#pragma warning disable CS0108
+#pragma warning restore CS0108
 
         protected override void initInstances() {
             base.initInstances();

com.unity.uiwidgets/Runtime/rendering/object.mixin.gen.cs

         where ConstraintType : Constraints 
         where ChildType : RenderObject {
         
-        public  LayoutCallback<ConstraintType> _callback { get; set; }
-        public void updateCallback(LayoutCallback<ConstraintType> value) {
+        public virtual LayoutCallback<ConstraintType> _callback { get; set; }
+        public virtual void updateCallback(LayoutCallback<ConstraintType> value) {
             if (value == _callback)
                 return;
             _callback = value;
-        public void layoutAndBuildChild() {
+        public virtual void layoutAndBuildChild() {
             D.assert(_callback != null);
             invokeLayoutCallback(_callback);
         }
         where ConstraintType : BoxConstraints 
         where ChildType : RenderBox {
         
-        public  LayoutCallback<ConstraintType> _callback { get; set; }
-        public void updateCallback(LayoutCallback<ConstraintType> value) {
+        public virtual LayoutCallback<ConstraintType> _callback { get; set; }
+        public virtual void updateCallback(LayoutCallback<ConstraintType> value) {
             if (value == _callback)
                 return;
             _callback = value;
-        public void layoutAndBuildChild() {
+        public virtual void layoutAndBuildChild() {
             D.assert(_callback != null);
             invokeLayoutCallback(_callback);
         }
         where ConstraintType : SliverConstraints 
         where ChildType : RenderSliver {
         
-        public  LayoutCallback<ConstraintType> _callback { get; set; }
-        public void updateCallback(LayoutCallback<ConstraintType> value) {
+        public virtual LayoutCallback<ConstraintType> _callback { get; set; }
+        public virtual void updateCallback(LayoutCallback<ConstraintType> value) {
             if (value == _callback)
                 return;
             _callback = value;
-        public void layoutAndBuildChild() {
+        public virtual void layoutAndBuildChild() {
             D.assert(_callback != null);
             invokeLayoutCallback(_callback);
         }

com.unity.uiwidgets/Runtime/rendering/object.mixin.njk

         where ConstraintType : {{constraint}} 
         where ChildType : {{with}} {
         
-        public  LayoutCallback<ConstraintType> _callback { get; set; }
-        public void updateCallback(LayoutCallback<ConstraintType> value) {
+        public virtual LayoutCallback<ConstraintType> _callback { get; set; }
+        public virtual void updateCallback(LayoutCallback<ConstraintType> value) {
             if (value == _callback)
                 return;
             _callback = value;
-        public void layoutAndBuildChild() {
+        public virtual void layoutAndBuildChild() {
             D.assert(_callback != null);
             invokeLayoutCallback(_callback);
         }

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

         }
 
 
-        bool alwaysNeedsCompositing
+        protected override bool alwaysNeedsCompositing
         {
             get { return child != null && (_alpha != 0 && _alpha != 255); }
         }
                 if (_opacity == value)
                     return;
                 bool didNeedCompositing = alwaysNeedsCompositing;
-                bool wasVisible = _alpha != 0;
                 _opacity = value;
                 _alpha = ui.Color.getAlphaFromOpacity(_opacity);
                 if (didNeedCompositing != alwaysNeedsCompositing)

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

                 });
             }
         }
-        public void setDebugChildIntegrityEnabled(bool enabled) {
+        public void setDebugChildIntegrityEnabled(bool? enabled) {
-                _debugChildIntegrityEnabled = enabled;
+                _debugChildIntegrityEnabled = enabled.Value;
                 return _debugVerifyChildOrder() &&
                        (!_debugChildIntegrityEnabled || _debugDanglingKeepAlives.isEmpty());
             });

com.unity.uiwidgets/Runtime/scheduler/binding.cs

 
         public SchedulingStrategy schedulingStrategy = scheduler_.defaultSchedulingStrategy;
 
-        public static SchedulerBinding instance {
+#pragma warning disable CS0108
+        public new static SchedulerBinding instance {
+#pragma warning restore CS0108
 
         public AppLifecycleState? lifecycleState { get; private set; }
 
         }
         
         static readonly TimeSpan _coolDownDelay = new TimeSpan(0, 0, 0, 0, 200);
+        
+#pragma warning disable CS0414
+#pragma warning restore CS0414
         
         public void scheduleFrame() {
             if (hasScheduledFrame || !framesEnabled) {

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

             window.onPlatformMessage = defaultBinaryMessenger.handlePlatformMessage;
             //SystemChannels.system.setMessageHandler(handleSystemMessage);
         }
-
-        public static ServicesBinding instance {
+        
+#pragma warning disable CS0108
+        public new static ServicesBinding instance {
+#pragma warning restore CS0108
 
         public BinaryMessenger defaultBinaryMessenger => _defaultBinaryMessenger;
         BinaryMessenger _defaultBinaryMessenger;

com.unity.uiwidgets/Runtime/widgets/DirectionalFocusTraversalPolicy.mixin.gen.cs

                 }
             }
         }
-        public override FocusNode findFirstFocusInDirection(FocusNode currentNode, TraversalDirection direction) {
+        public override FocusNode findFirstFocusInDirection(FocusNode currentNode, TraversalDirection? direction) {
             D.assert(direction != null);
             D.assert(currentNode != null);
             switch (direction) { 

com.unity.uiwidgets/Runtime/widgets/DirectionalFocusTraversalPolicy.mixin.njk

                 }
             }
         }
-        public override FocusNode findFirstFocusInDirection(FocusNode currentNode, TraversalDirection direction) {
+        public override FocusNode findFirstFocusInDirection(FocusNode currentNode, TraversalDirection? direction) {
             D.assert(direction != null);
             D.assert(currentNode != null);
             switch (direction) { 

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

         public static readonly Intent doNothing = new Intent(DoNothingAction.key);
         public readonly LocalKey key;
 
-        public bool isEnabled(BuildContext context) => true;
+        public virtual bool isEnabled(BuildContext context) => true;
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
             base.debugFillProperties(properties);
             properties.add(new DiagnosticsProperty<LocalKey>("key", key));

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

 
             ColorFilter _colorFilter;
             
-            public  bool alwaysNeedsCompositing {
+            protected override bool alwaysNeedsCompositing {
                 get { return child != null; }
             }
             

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

             return candidate;
         }
         
-        public abstract FocusNode findFirstFocusInDirection(FocusNode currentNode, TraversalDirection direction);
+        public abstract FocusNode findFirstFocusInDirection(FocusNode currentNode, TraversalDirection? direction);
 
         public virtual void invalidateScopeData(FocusScopeNode node) {
         }
     public interface DirectionalFocusTraversalPolicyMixin {
         void invalidateScopeData(FocusScopeNode node);
         void changedScope(FocusNode node = null, FocusScopeNode oldScope = null);
-        FocusNode findFirstFocusInDirection(FocusNode currentNode, TraversalDirection direction);
         FocusNode _sortAndFindInitial(FocusNode currentNode, bool vertical = false, bool first = false);
 
         IEnumerable<FocusNode> _sortAndFilterHorizontally(

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

 
         internal Widget _widget;
         
-        public virtual Widget widget {
+        public Widget widget {
             get { return _widget; }
         }
         
             };
             visitChildren(applyParentDataToChild);
         }
-        
-
-        public new void applyWidgetOutOfTurn(ParentDataWidget<T> newWidget) {
-            D.assert(newWidget != null);
-            D.assert(newWidget.debugCanApplyOutOfTurn());
-            D.assert(newWidget.child == widget.child);
-            _applyParentData(newWidget);
-        }
 
         public override void notifyClients(ProxyWidget oldWidget) {
             _applyParentData((ParentDataWidget<T>) widget);
         protected RenderObjectElement(RenderObjectWidget widget) : base(widget) {
         }
 
-        public new RenderObjectWidget widget {
+#pragma warning disable CS0108
+        public RenderObjectWidget widget {
+#pragma warning restore CS0108
 
         RenderObject _renderObject;
         

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

             Dictionary<string, object> json = base.toJsonMap(_delegate);
         if (value != null) {
             json["valueProperties"] = new Dictionary<string, object>(){
-                {"codePoint", value.codePoint},
+                {"codePoint", valueT.codePoint},
             };
         }
         return json;

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

             return new Padding(
                 padding: _padding
                     .evaluate(animation)
-                    .clamp(EdgeInsets.zero, EdgeInsetsGeometry.infinity),
+                    .clamp(EdgeInsets.zero, EdgeInsetsGeometry.infinityEdgeInsetsGeometry),
                 child: widget.child
             );
         }
         public readonly TextOverflow overflow;
 
         public readonly int? maxLines;
-
-        public readonly VoidCallback onEnd;
 
         public override State createState() {
             return new _AnimatedDefaultTextStyleState();

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

             return  new _InheritedNotifierElement<T>(this);
         }
     }
-    public class _InheritedNotifierElement<T> : InheritedElement where T : Listenable{ 
+    public class _InheritedNotifierElement<T> : InheritedElement where T : Listenable
+    { 
         public _InheritedNotifierElement(InheritedNotifier<T> widget) : base(widget) {
             widget.notifier?.addListener(_handleUpdate);
         }
                 return base.widget as InheritedNotifier<T>;
             }
         }
+        
+        //In flutter this variable is named as _dirty and hides the property of its parent with the name variable name
+        //We give it a new name, i.e., _notifier_dirty in UIWidgets so that the code looks more clear
+        bool _notifier_dirty = false;
-        public bool _dirty = false;
         public override void update( Widget newWidget) {
             newWidget = (InheritedNotifier<T>) newWidget;
             T oldNotifier = widget.notifier;
         }
 
         protected override Widget build() {
-            if (_dirty)
+            if (_notifier_dirty)
-            _dirty = true;
+            _notifier_dirty = true;
             markNeedsBuild();
         }
 
-            _dirty = false;
+            _notifier_dirty = false;
         }
         public override void unmount() {
             widget.notifier?.removeListener(_handleUpdate);

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

             return new _LayoutBuilderElement<ConstraintType>(this);
         }
 
-        public readonly ConstraintBuilder builder;
-
+        public virtual ConstraintBuilder builder { get; }
     }
 
 

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

 
     public abstract class RouteTransitionRecord {
 
-        public Route route;
+        public abstract Route route { get; }
-        public bool isEntering;
+        public abstract bool isEntering { get; }
 
         public bool _debugWaitingForExitDecision = false;
         public abstract void markForPush();
             this.route = route;
             currentState = initialState;
         }
-
-        public Route route;
+        
         public _RouteLifecycle currentState;
         public Route lastAnnouncedPreviousRoute; // last argument to Route.didChangePrevious
         public Route lastAnnouncedPoppedNextRoute; // last argument to Route.didPopNext
             return (_RouteEntry entry) => entry.route == route;
         }
 
+        public override Route route { get; }
-        public bool isEntering {
+        public override bool isEntering {
             get { return currentState == _RouteLifecycle.staging; }
         }
 

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

         ) : base(settings : settings) {
         }
         
-        protected internal new bool didPop(T result) {
+        protected internal override bool didPop(object result) {
             var returnValue = base.didPop(result);
             D.assert(returnValue);
             if (finishedWhenPopped) {
             _filter = filter;
         }
         
-        public static ModalRoute<T> of<T>(BuildContext context) {
+        public static ModalRoute<S> of<S>(BuildContext context) {
-            return widget?.route as ModalRoute<T>;
+            return widget?.route as ModalRoute<S>;
         }
 
         public override Widget _buildModalScope(BuildContext context) {

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

 
         public readonly ScrollIncrementType type;
 
-        protected bool isEnabled(BuildContext context) {
+        public override bool isEnabled(BuildContext context) {
             return Scrollable.of(context) != null;
         }
     }
 
         float _calculateScrollIncrement(ScrollableState state, ScrollIncrementType type = ScrollIncrementType.line) {
             D.assert(state.position != null);
-            D.assert(state.position.pixels != null);
+            D.assert(state.position.havePixels);
             D.assert(state.widget.physics == null || state.widget.physics.shouldAcceptUserOffset(state.position));
 
             if (state.widget.incrementCalculator != null) {

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

 
         protected override string valueToString(TextTreeConfiguration parentConfiguration = null) {
             var res = new List<string>();
-            foreach (var key in value.Keys) {
-                var temp = "{" + key.debugDescribeKeys() + "}:" + value[key: key];
+            foreach (var key in valueT.Keys) {
+                var temp = "{" + key.debugDescribeKeys() + "}:" + valueT[key: key];
                 res.Add(item: temp);
             }
 

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

         public _SliverOffstageElement(SliverOffstage widget) : base(widget) {
         }
 
-        public SliverOffstage widget {
+#pragma warning disable CS0108
+        public new SliverOffstage widget {
+#pragma warning restore CS0108
 
         public override void debugVisitOnstageChildren(ElementVisitor visitor) {
             if (!widget.offstage)

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

 using System.Collections.Generic;
 using Unity.UIWidgets.foundation;
-using Unity.UIWidgets.painting;
 using Unity.UIWidgets.rendering;
 using Unity.UIWidgets.ui;
 
             
         }
 
-        public static SliverLayoutBuilder Creat(
-            Key key = null,
-            SliverLayoutWidgetBuilder builder = null
-            ) {
-            ConstraintBuilder _builder = (context, constraints) => {
-                return builder(context, (SliverConstraints)constraints);
-            };
-            return new SliverLayoutBuilder(key,_builder);
-        }
-
-        public new SliverLayoutWidgetBuilder builder {
-            get {
-                //return base.builder;
-                SliverLayoutWidgetBuilder _builder = (context, constraints) => {
-                    return base.builder(context, (SliverConstraints) constraints);
-                };
-                return _builder;
-            }
-        }
-
         public override RenderObject createRenderObject(BuildContext context) {
             return new _RenderSliverLayoutBuilder();
         }
                    && child.hitTest(result, mainAxisPosition: mainAxisPosition, crossAxisPosition: crossAxisPosition);
         }
 
-        public bool debugValidateChild(RenderObject child) {
+        public override bool debugValidateChild(RenderObject child) {
             D.assert(() => {
                 if (!(child is RenderSliver)) {
                     throw new UIWidgetsError(
             }
         }
 
-        public LayoutCallback<SliverConstraints> _callback { get; set; }
-        public void updateCallback(LayoutCallback<SliverConstraints> value) {
+        public override LayoutCallback<SliverConstraints> _callback { get; set; }
+        
+        public override void updateCallback(LayoutCallback<SliverConstraints> value) {
             if (value == _callback)
                 return;
             _callback = value;
-        public void layoutAndBuildChild() {
+        public override void layoutAndBuildChild() {
             D.assert(_callback != null);
             invokeLayoutCallback(_callback);
         }

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

             
         }
 
-        public _SliverPersistentHeaderElement _element {
+        public override _SliverPersistentHeaderElement _element {
             get { return _ele; }
             set { _ele = value; }
         }
             get { return _element.widget.layoutDelegate.maxExtent; }
         }
 
-        public void updateChild(float shrinkOffset, bool overlapsContent) {
+        protected override void updateChild(float shrinkOffset, bool overlapsContent) {
-        public void triggerRebuild() {
+        protected override void triggerRebuild() {
             markNeedsLayout();
         }
     }
         ) {
         }
 
-        public _SliverPersistentHeaderElement _element {
+        public override _SliverPersistentHeaderElement _element {
             get { return sliver_persistent_header_utils._element; }
             set { sliver_persistent_header_utils._element = value; }
         }
             get { return _element.widget.layoutDelegate.maxExtent; }
         }
 
-        public void updateChild(float shrinkOffset, bool overlapsContent) {
+        protected override void updateChild(float shrinkOffset, bool overlapsContent) {
-        public void triggerRebuild() {
+        protected override void triggerRebuild() {
             markNeedsLayout();
         }
     }
         ) {
         }
 
-        public _SliverPersistentHeaderElement _element {
+        public override _SliverPersistentHeaderElement _element {
             get { return _ele; }
             set { _ele = value; }
         }
             get { return _element.widget.layoutDelegate.maxExtent; }
         }
 
-        public void updateChild(float shrinkOffset, bool overlapsContent) {
+        protected override void updateChild(float shrinkOffset, bool overlapsContent) {
-        public void triggerRebuild() {
+        protected override void triggerRebuild() {
             markNeedsLayout();
         }
     }
         ) {
         }
 
-        public _SliverPersistentHeaderElement _element {
+        public override _SliverPersistentHeaderElement _element {
             get { return _ele; }
             set { _ele = value; }
         }
             get { return _element.widget.layoutDelegate.maxExtent; }
         }
 
-        public void updateChild(float shrinkOffset, bool overlapsContent) {
+        protected override void updateChild(float shrinkOffset, bool overlapsContent) {
-        public void triggerRebuild() {
+        protected override void triggerRebuild() {
             markNeedsLayout();
         }
     }

com.unity.uiwidgets/Runtime/widgets/sliver_persistent_header.mixin.gen.cs

             _snapConfiguration = snapConfiguration;
         }
 
-         public _SliverPersistentHeaderElement _element {
+         public virtual _SliverPersistentHeaderElement _element {
              get {
                  return sliver_persistent_header_utils._element;
              }
             triggerRebuild();
         }
         
-        void triggerRebuild() {
+        protected virtual void triggerRebuild() {
             markNeedsLayout();
         }
         
             stretchConfiguration: stretchConfiguration) {
         }
 
-         public _SliverPersistentHeaderElement _element {
+         public virtual _SliverPersistentHeaderElement _element {
              get {
                  return sliver_persistent_header_utils._element;
              }
             triggerRebuild();
         }
         
-        void triggerRebuild() {
+        protected virtual void triggerRebuild() {
             markNeedsLayout();
         }
         
             stretchConfiguration: stretchConfiguration) {
         }
 
-         public _SliverPersistentHeaderElement _element {
+         public virtual _SliverPersistentHeaderElement _element {
              get {
                  return sliver_persistent_header_utils._element;
              }
             triggerRebuild();
         }
         
-        void triggerRebuild() {
+        protected virtual void triggerRebuild() {
             markNeedsLayout();
         }
         
             stretchConfiguration: stretchConfiguration) {
         }
 
-         public _SliverPersistentHeaderElement _element {
+         public virtual _SliverPersistentHeaderElement _element {
              get {
                  return sliver_persistent_header_utils._element;
              }
             triggerRebuild();
         }
         
-        void triggerRebuild() {
+        protected virtual void triggerRebuild() {
             markNeedsLayout();
         }
         

com.unity.uiwidgets/Runtime/widgets/sliver_persistent_header.mixin.njk

             _snapConfiguration = snapConfiguration;
         }
 
-         public _SliverPersistentHeaderElement _element {
+         public virtual _SliverPersistentHeaderElement _element {
              get {
                  return sliver_persistent_header_utils._element;
              }
             triggerRebuild();
         }
         
-        void triggerRebuild() {
+        protected virtual void triggerRebuild() {
             markNeedsLayout();
         }
         
             stretchConfiguration: stretchConfiguration) {
         }
 
-         public _SliverPersistentHeaderElement _element {
+         public virtual _SliverPersistentHeaderElement _element {
              get {
                  return sliver_persistent_header_utils._element;
              }
             triggerRebuild();
         }
         
-        void triggerRebuild() {
+        protected virtual void triggerRebuild() {
             markNeedsLayout();
         }
         
             stretchConfiguration: stretchConfiguration) {
         }
 
-         public _SliverPersistentHeaderElement _element {
+         public virtual _SliverPersistentHeaderElement _element {
              get {
                  return sliver_persistent_header_utils._element;
              }
             triggerRebuild();
         }
         
-        void triggerRebuild() {
+        protected virtual void triggerRebuild() {
             markNeedsLayout();
         }
         
             stretchConfiguration: stretchConfiguration) {
         }
 
-         public _SliverPersistentHeaderElement _element {
+         public virtual _SliverPersistentHeaderElement _element {
              get {
                  return sliver_persistent_header_utils._element;
              }
             triggerRebuild();
         }
         
-        void triggerRebuild() {
+        protected virtual void triggerRebuild() {
             markNeedsLayout();
         }
         

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

 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using Unity.UIWidgets.async;
 using Unity.UIWidgets.external;
 using Unity.UIWidgets.foundation;
 using UnityEngine;
 using Canvas = Unity.UIWidgets.ui.Canvas;
 using Color = Unity.UIWidgets.ui.Color;
-using Debug = System.Diagnostics.Debug;
+    
+#pragma warning disable CS0414
-    public class WidgetInspectorUtils{
-        public static float _kScreenEdgeMargin = 10.0f;
-        public static float _kTooltipPadding = 5.0f;
-        public static float  _kInspectButtonMargin = 10.0f;
-        public static float _kOffScreenMargin = 1.0f;
+    public static class WidgetInspectorUtils
+    {
+        public const float _kScreenEdgeMargin = 10.0f;
+        public const float _kTooltipPadding = 5.0f;
+        public const float  _kInspectButtonMargin = 10.0f;
+        public const float _kOffScreenMargin = 1.0f;
-        public static TextStyle _messageStyle = new TextStyle(
+        public static readonly TextStyle _messageStyle = new TextStyle(
-        public static int _kMaxTooltipLines = 5;
-        public static Color _kTooltipBackgroundColor = Color.fromARGB(230, 60, 60, 60);
-        public static Color _kHighlightedRenderObjectFillColor = Color.fromARGB(128, 128, 128, 255);
-        public static Color _kHighlightedRenderObjectBorderColor = Color.fromARGB(128, 64, 64, 128);
+        
+        public const int _kMaxTooltipLines = 5;
+        public static readonly Color _kTooltipBackgroundColor = Color.fromARGB(230, 60, 60, 60);
+        public static readonly Color _kHighlightedRenderObjectFillColor = Color.fromARGB(128, 128, 128, 255);
+        public static readonly Color _kHighlightedRenderObjectBorderColor = Color.fromARGB(128, 64, 64, 128);
-        bool _isDebugCreator(DiagnosticsNode node) => node is DiagnosticsDebugCreator; 
-        IEnumerable transformDebugCreator(IEnumerable<DiagnosticsNode> properties) { 
+        static bool _isDebugCreator(DiagnosticsNode node) => node is DiagnosticsDebugCreator; 
+        
+        public static IEnumerable transformDebugCreator(IEnumerable<DiagnosticsNode> properties) { 
             List<DiagnosticsNode> result = new List<DiagnosticsNode>();
             List<DiagnosticsNode> pending = new List<DiagnosticsNode>();
             bool foundStackTrace = false;
         public static readonly Dictionary<_Location, int> _locationToId = new Dictionary<_Location, int>();
         public static readonly List<_Location> _locations = new List<_Location>();
 
-        public static int _toLocationId(_Location location) {
-            int id = _locationToId[location];
-            if (id != null) {
+        public static int? _toLocationId(_Location location) {
+            int id = _locationToId.getOrDefault(location, -1);
+            if (id != -1) {
                 return id;
             }
             id = _locations.Count;
         }
-        public IEnumerable _parseDiagnosticsNode(DiagnosticsNode node) { 
+        static IEnumerable _parseDiagnosticsNode(DiagnosticsNode node) { 
             if (!_isDebugCreator(node))
                 return null;
             DebugCreator debugCreator = node.value as DebugCreator;
-        public IEnumerable<DiagnosticsNode> _describeRelevantUserCode(Element element) {
+        static IEnumerable<DiagnosticsNode> _describeRelevantUserCode(Element element) {
             if (!WidgetInspectorService.instance.isWidgetCreationTracked()) {
                 return new List<DiagnosticsNode>() {
                     new ErrorDescription(
             return nodes;
         }
 
-        public bool _isLocalCreationLocation(object _object){ 
+        static bool _isLocalCreationLocation(object _object){ 
-        public string _describeCreationLocation(object _object) {
+        
+        static string _describeCreationLocation(object _object) {
+        
         public static _Location _getCreationLocation(object _object) { 
             object candidate =  _object is Element ? ((Element)_object).widget : _object;
             return candidate is _HasCreationLocation ? ((_HasCreationLocation)candidate)._location : null;
 
 
     }
-    public abstract class _HasCreationLocation {
-        public _Location _location { get; }
+    public interface _HasCreationLocation {
+        _Location _location { get; }
     }
 
     public class _ProxyLayer : Layer {
         Canvas _screenshotCanvas;
         _MulticastCanvas _multicastCanvas;
 
-        public Canvas canvas {
+        public override Canvas canvas {
             get {
                 if (_data.includeInScreenshot) {
                     if (_screenshotCanvas == null) {
         public readonly string groupName;
         public readonly bool summaryTree;
         public readonly int maxDescendentsTruncatableNode;
-        public readonly bool expandPropertyValues;
-        public readonly int subtreeDepth;
-        public readonly bool includeProperties;
+
+        public override int subtreeDepth { get; }
+        public override bool includeProperties { get; }
+        public override bool expandPropertyValues { get; }
+
         public readonly WidgetInspectorService service; 
         public readonly AddAdditionalPropertiesCallback addAdditionalPropertiesCallback ;
         public readonly List<DiagnosticsNode> _nodesCreatedByLocalProject = new List<DiagnosticsNode>();
             return false;
         }
     }
+#pragma warning restore CS0414
 }