Merge branch 'dragdrop_fix' into 'master'

fix warnings + add two more rules to editorconfig

See merge request upm-packages/ui-widgets/com.unity.uiwidgets!36

.editorconfig

 # not requirement for converting named arguments into positioned arguments whenever possible
 csharp_arguments_named=named
 
+# add braces whenever necessary
+csharp_braces_for_ifelse=required
+csharp_braces_for_for=required
+csharp_braces_for_foreach=required
+csharp_braces_for_while=required
+csharp_braces_for_dowhile=required
+csharp_braces_for_using=required
+csharp_braces_for_fixed=required
+csharp_braces_redundant=true
+
+
+# prefer block_body to expression_body
+csharp_method_or_operator_body=block_body
+csharp_local_function_body=block_body
+csharp_constructor_or_destructor_body=block_body
+csharp_accessor_owner_body=accessors_with_block_body
+
+
 
 ###################
 # CODE INSPECTION #

Runtime/material/button.cs

 
         public readonly Widget child;
 
-        public bool enabled => this.onPressed != null;
+        public bool enabled {
+            get { return this.onPressed != null; }
+        }
-        public override State createState() => new _RawMaterialButtonState();
+        public override State createState() {
+            return new _RawMaterialButtonState();
+        }
     }
 
 

Runtime/material/button_theme.cs

             return buttonTheme;
         }
 
-        public override bool updateShouldNotify(InheritedWidget oldWidget) =>
-            this.data != ((ButtonTheme) oldWidget).data;
+        public override bool updateShouldNotify(InheritedWidget oldWidget) {
+            return this.data != ((ButtonTheme) oldWidget).data;
+        }
     }
 
 
 
         public EdgeInsets padding {
             get {
-                if (this._padding != null)
+                if (this._padding != null) {
+                }
+
                 switch (this.textTheme) {
                     case ButtonTextTheme.normal:
                     case ButtonTextTheme.accent:
 
         public ShapeBorder shape {
             get {
-                if (this._shape != null)
+                if (this._shape != null) {
+                }
+
                 switch (this.textTheme) {
                     case ButtonTextTheme.normal:
                     case ButtonTextTheme.accent:
 
 
         Color getDisabledTextColor(MaterialButton button) {
-            if (button.disabledTextColor != null)
+            if (button.disabledTextColor != null) {
+            }
+
-            if (button.disabledColor != null)
+            if (button.disabledColor != null) {
-            if (this._disabledColor != null)
+            }
+
+            if (this._disabledColor != null) {
+            }
+
             return this._getDisabledColor(button);
         }
 
-            if (fillColor != null)
+            if (fillColor != null) {
+            }
 
 //    todo xingwei.zhu: uncomment these when FlatButton & OutlineButton & RaisedButton are ready
 //            if (button is FlatButton || button is OutlineButton)
         }
 
         public Color getTextColor(MaterialButton button) {
-            if (!button.enabled)
+            if (!button.enabled) {
+            }
-            if (button.textColor != null)
+            if (button.textColor != null) {
+            }
 
             switch (this.getTextTheme(button)) {
                 case ButtonTextTheme.normal:
                     bool fillIsDark = fillColor != null
                         ? ThemeData.estimateBrightnessForColor(fillColor) == Brightness.dark
                         : this.getBrightness(button) == Brightness.dark;
-                    if (fillIsDark)
+                    if (fillIsDark) {
+                    }
+
 //    todo xingwei.zhu: uncomment these when FlatButton & OutlineButton are ready
 //                    if (button is FlatButton || button is OutlineButton)
 //                        return this.colorScheme.primary;
         }
 
         public Color getSplashColor(MaterialButton button) {
-            if (button.splashColor != null)
+            if (button.splashColor != null) {
+            }
 
 //    todo xingwei.zhu: uncomment these when FlatButton & OutlineButton & RaisedButton are ready
 //            if (this._splashColor != null && (button is RaisedButton || button is OutlineButton)) {
         }
 
         public Color getHighlightColor(MaterialButton button) {
-            if (button.highlightColor != null)
+            if (button.highlightColor != null) {
+            }
 
             switch (this.getTextTheme(button)) {
                 case ButtonTextTheme.normal:
 
 
         public double getElevation(MaterialButton button) {
-            if (button.elevation != null)
+            if (button.elevation != null) {
+            }
+
 //    todo xingwei.zhu: uncomment these when FlatButton are ready            
 //            if (button is FlatButton)
 //                return 0.0;
 
         public double getHighlightElevation(MaterialButton button) {
-            if (button.highlightElevation != null)
+            if (button.highlightElevation != null) {
+            }
+
 //    todo xingwei.zhu: uncomment these when FlatButton & OutlineButton are ready 
 //            if (button is FlatButton)
 //                return 0.0;
 
 
         public double getDisabledElevation(MaterialButton button) {
-            if (button.disabledElevation != null)
+            if (button.disabledElevation != null) {
+            }
+
-            if (button.padding != null)
+            if (button.padding != null) {
+            }
-            if (this._padding != null)
+            if (this._padding != null) {
+            }
 
             switch (this.getTextTheme(button)) {
                 case ButtonTextTheme.normal:
             return button.animationDuration ?? Constants.kThemeChangeDuration;
         }
 
-        public BoxConstraints getConstraints(MaterialButton button) => this.constraints;
+        public BoxConstraints getConstraints(MaterialButton button) {
+            return this.constraints;
+        }
 
 
         public MaterialTapTargetSize getMaterialTapTargetSize(MaterialButton button) {

Runtime/material/color_scheme.cs

         }
 
 
-        static Brightness _brightnessFor(Color color) => ThemeData.estimateBrightnessForColor(color);
+        static Brightness _brightnessFor(Color color) {
+            return ThemeData.estimateBrightnessForColor(color);
+        }
 
 
         public readonly Color primary;

Runtime/material/colors.cs

     public class MaterialColor : ColorSwatch<int> {
         public MaterialColor(
             long primary,
-            Dictionary<int, Color> swatch) : base(primary: primary, swatch: swatch) {}
+            Dictionary<int, Color> swatch) : base(primary: primary, swatch: swatch) {
+        }
-        public Color shade50 => this[50];
+        public Color shade50 {
+            get { return this[50]; }
+        }
-        public Color shade100 => this[100];
+        public Color shade100 {
+            get { return this[100]; }
+        }
-        public Color shade200 => this[200];
+        public Color shade200 {
+            get { return this[200]; }
+        }
-        public Color shade300 => this[300];
+        public Color shade300 {
+            get { return this[300]; }
+        }
-        public Color shade400 => this[400];
+        public Color shade400 {
+            get { return this[400]; }
+        }
-        public Color shade500 => this[500];
+        public Color shade500 {
+            get { return this[500]; }
+        }
-        public Color shade600 => this[600];
+        public Color shade600 {
+            get { return this[600]; }
+        }
-        public Color shade700 => this[700];
+        public Color shade700 {
+            get { return this[700]; }
+        }
-        public Color shade800 => this[800];
+        public Color shade800 {
+            get { return this[800]; }
+        }
-        public Color shade900 => this[900];
+        public Color shade900 {
+            get { return this[900]; }
+        }
     }
 
 
             Dictionary<int, Color> swatch) : base(primary: primary, swatch: swatch) {
         }
 
-        public Color shade50 => this[50];
+        public Color shade50 {
+            get { return this[50]; }
+        }
-        public Color shade100 => this[100];
+        public Color shade100 {
+            get { return this[100]; }
+        }
-        public Color shade200 => this[200];
+        public Color shade200 {
+            get { return this[200]; }
+        }
-        public Color shade400 => this[400];
+        public Color shade400 {
+            get { return this[400]; }
+        }
-        public Color shade700 => this[700];
+        public Color shade700 {
+            get { return this[700]; }
+        }
     }
 
 
         public static readonly MaterialColor indigo = new MaterialColor(
             _indigoPrimaryValue,
             new Dictionary<int, Color> {
-                {50, new Color(0xFFE8EAF6)}, 
+                {50, new Color(0xFFE8EAF6)},
                 {100, new Color(0xFFC5CAE9)},
                 {200, new Color(0xFF9FA8DA)},
                 {300, new Color(0xFF7986CB)},

Runtime/material/debug.cs

                     });
                     if (ancestors.isNotEmpty()) {
                         message += "The ancestors of this widget were:";
-                        foreach (Widget ancestor in ancestors)
+                        foreach (Widget ancestor in ancestors) {
+                        }
                     }
                     else {
                         message += "This widget is the root of the tree, so it has no " +

Runtime/material/ink_decoration.cs

 
         public EdgeInsets _paddingIncludingDecoration {
             get {
-                if (this.decoration == null || this.decoration.padding == null)
+                if (this.decoration == null || this.decoration.padding == null) {
+                }
+
-                if (this.padding == null)
+                if (this.padding == null) {
+                }
 
                 return this.padding.add(decorationPadding);
             }
             properties.add(new DiagnosticsProperty<Decoration>("bg", this.decoration, defaultValue: null));
         }
 
-        public override State createState() => new _InkState();
+        public override State createState() {
+            return new _InkState();
+        }
     }
 
 
 
             Widget current = this.widget.child;
             EdgeInsets effectivePadding = this.widget._paddingIncludingDecoration;
-            if (effectivePadding != null)
+            if (effectivePadding != null) {
+            }
 
             return current;
         }
         public Decoration decoration {
             get { return this._decoration; }
             set {
-                if (value == this._decoration)
+                if (value == this._decoration) {
+                }
+
                 this._decoration = value;
                 this._painter?.Dispose();
                 this._painter = this._decoration?.createBoxPainter(this._handleChanged);
             get { return this._configuration; }
             set {
                 D.assert(value != null);
-                if (value == this._configuration)
+                if (value == this._configuration) {
+                }
+
                 this._configuration = value;
                 this.controller.markNeedsPaint();
             }
         }
 
         protected override void paintFeature(Canvas canvas, Matrix3 transform) {
-            if (this._painter == null)
+            if (this._painter == null) {
+            }
+
             Offset originOffset = transform.getAsTranslation();
             ImageConfiguration sizedConfiguration = this.configuration.copyWith(
                 size: this.referenceBox.size);

Runtime/material/ink_highlight.cs

             this._borderRadius = borderRadius ?? BorderRadius.zero;
             this._customBorder = customBorder;
             this._rectCallback = rectCallback;
-            
+
             this._alphaController = new AnimationController(
                 duration: InkHighlightUtils._kHighlightFadeDuration,
                 vsync: controller.vsync);
         Animation<int> _alpha;
         AnimationController _alphaController;
 
-        public bool active => this._active;
+        public bool active {
+            get { return this._active; }
+        }
+
         bool _active = true;
 
         public void activate() {
         }
 
         void _handleAlphaStatusChanged(AnimationStatus status) {
-            if (status == AnimationStatus.dismissed && !this._active)
+            if (status == AnimationStatus.dismissed && !this._active) {
+            }
         }
 
         public override void dispose() {
 
         void _paintHighlight(Canvas canvas, Rect rect, Paint paint) {
-            D.assert(this._shape != null);
             canvas.save();
             if (this._customBorder != null) {
                 canvas.clipPath(this._customBorder.getOuterPath(rect));
                     break;
                 }
             }
+
             canvas.restore();
         }
 

Runtime/material/ink_splash.cs

         }
 
         void _handleAlphaStatusChanged(AnimationStatus status) {
-            if (status == AnimationStatus.completed)
+            if (status == AnimationStatus.completed) {
+            }
         }
 
         public override void dispose() {
         protected override void paintFeature(Canvas canvas, Matrix3 transform) {
             Paint paint = new Paint {color = this.color.withAlpha(this._alpha.value)};
             Offset center = this._position;
-            if (this._repositionToReferenceBox)
+            if (this._repositionToReferenceBox) {
+            }
+
             Offset originOffset = transform.getAsTranslation();
             canvas.save();
             if (originOffset == null) {
             }
 
             //todo xingwei.zhu: remove this condition when drawCircle bug fixed (when radius.value == 0)
-            if (this._radius.value != 0)
+            if (this._radius.value != 0) {
+            }
+
             canvas.restore();
         }
     }

Runtime/material/ink_well.cs

         public Color color {
             get { return this._color; }
             set {
-                if (value == this._color)
+                if (value == this._color) {
+                }
+
                 this._color = value;
                 this.controller.markNeedsPaint();
             }
 
         public readonly InteractiveInkFeatureFactory splashFactory;
 
-        public virtual RectCallback getRectCallback(RenderBox referenceBox) => null;
+        public virtual RectCallback getRectCallback(RenderBox referenceBox) {
+            return null;
+        }
 
 
         public virtual bool debugCheckContext(BuildContext context) {
 
-        public override State createState() => new _InkResponseState<InkResponse>();
+        public override State createState() {
+            return new _InkResponseState<InkResponse>();
+        }
-            if (this.onTap != null)
+            if (this.onTap != null) {
-            if (this.onDoubleTap != null)
+            }
+
+            if (this.onDoubleTap != null) {
-            if (this.onLongPress != null)
+            }
+
+            if (this.onLongPress != null) {
-            if (this.onTapDown != null)
+            }
+
+            if (this.onTapDown != null) {
-            if (this.onTapCancel != null)
+            }
+
+            if (this.onTapCancel != null) {
+            }
+
             properties.add(new EnumerableProperty<string>("gestures", gestures, ifEmpty: "<none>"));
             properties.add(new DiagnosticsProperty<bool>("containedInkWell", this.containedInkWell,
                 level: DiagnosticLevel.fine));
         InteractiveInkFeature _currentSplash;
         InkHighlight _lastHighlight;
 
-        protected override bool wantKeepAlive =>
-            this._lastHighlight != null || (this._splashes != null && this._splashes.isNotEmpty());
+        protected override bool wantKeepAlive {
+            get { return this._lastHighlight != null || (this._splashes != null && this._splashes.isNotEmpty()); }
+        }
-            if (value == (this._lastHighlight != null && this._lastHighlight.active))
+            if (value == (this._lastHighlight != null && this._lastHighlight.active)) {
+            }
+
             if (value) {
                 if (this._lastHighlight == null) {
                     RenderBox referenceBox = (RenderBox) this.context.findRenderObject();
             }
 
             D.assert(value == (this._lastHighlight != null && this._lastHighlight.active));
-            if (this.widget.onHighlightChanged != null)
+            if (this.widget.onHighlightChanged != null) {
+            }
         }
 
         void _handleInkHighlightRemoval() {
                 if (this._splashes != null) {
                     D.assert(this._splashes.Contains(splash));
                     this._splashes.Remove(splash);
-                    if (this._currentSplash == splash) this._currentSplash = null;
+                    if (this._currentSplash == splash) {
+                        this._currentSplash = null;
+                    }
+
                     this.updateKeepAlive();
                 }
             }
             if (this._splashes != null) {
                 HashSet<InteractiveInkFeature> splashes = this._splashes;
                 this._splashes = null;
-                foreach (InteractiveInkFeature splash in splashes)
+                foreach (InteractiveInkFeature splash in splashes) {
+                }
+
                 this._currentSplash = null;
             }
 
             D.assert(this.widget.debugCheckContext(context));
             base.build(context);
             ThemeData themeData = Theme.of(context);
-            if (this._lastHighlight != null)
+            if (this._lastHighlight != null) {
-            if (this._currentSplash != null)
+            }
+
+            if (this._currentSplash != null) {
+            }
+
             bool enabled = this.widget.onTap != null || this.widget.onDoubleTap != null ||
                            this.widget.onLongPress != null;
 
                 onTapCancel: enabled ? (GestureTapCancelCallback) this._handleTapCancel : null,
-                onDoubleTap: this.widget.onDoubleTap != null ? (GestureDoubleTapCallback) (details => this._handleDoubleTap()) : null,
+                onDoubleTap: this.widget.onDoubleTap != null
+                    ? (GestureDoubleTapCallback) (details => this._handleDoubleTap())
+                    : null,
                 onLongPress: this.widget.onLongPress != null
                     ? (GestureLongPressCallback) (() => this._handleLongPress(context))
                     : null,

Runtime/material/material.cs

             return result;
         }
 
-        public override State createState() => new _MaterialState();
+        public override State createState() {
+            return new _MaterialState();
+        }
 
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder properties) {
         readonly GlobalKey _inkFeatureRenderer = GlobalKey.key(debugLabel: "ink renderer");
 
         Color _getBackgroundColor(BuildContext context) {
-            if (this.widget.color != null)
+            if (this.widget.color != null) {
+            }
+
             switch (this.widget.type) {
                 case MaterialType.canvas:
                     return Theme.of(context).canvasColor;
 
 
         ShapeBorder _getShape() {
-            if (this.widget.shape != null)
+            if (this.widget.shape != null) {
-            if (this.widget.borderRadius != null)
+            }
+
+            if (this.widget.borderRadius != null) {
+            }
+
             switch (this.widget.type) {
                 case MaterialType.canvas:
                 case MaterialType.transparency:
                     return new RoundedRectangleBorder(
-                        borderRadius: this.widget.borderRadius ?? MaterialConstantsUtils.kMaterialEdges[this.widget.type]);
+                        borderRadius: this.widget.borderRadius ??
+                                      MaterialConstantsUtils.kMaterialEdges[this.widget.type]);
                 case MaterialType.circle:
                     return new CircleBorder();
             }
         }
 
         public void _didChangeLayout() {
-            if (this._inkFeatures != null && this._inkFeatures.isNotEmpty())
+            if (this._inkFeatures != null && this._inkFeatures.isNotEmpty()) {
+            }
-        protected override bool hitTestSelf(Offset position) => true;
+        protected override bool hitTestSelf(Offset position) {
+            return true;
+        }
 
         public override void paint(PaintingContext context, Offset offset) {
             if (this._inkFeatures != null && this._inkFeatures.isNotEmpty()) {
                 canvas.clipRect(Offset.zero & this.size);
-                foreach (InkFeature inkFeature in this._inkFeatures)
+                foreach (InkFeature inkFeature in this._inkFeatures) {
+                }
+
                 canvas.restore();
             }
 
             this.onRemoved = onRemoved;
         }
 
-        public MaterialInkController controller => this._controller;
+        public MaterialInkController controller {
+            get { return this._controller; }
+        }
+
         public _RenderInkFeatures _controller;
 
         public readonly RenderBox referenceBox;
                 return true;
             });
             this._controller._removeFeature(this);
-            if (this.onRemoved != null)
+            if (this.onRemoved != null) {
+            }
         }
 
         public void _paint(Canvas canvas) {
 
             Matrix3 transform = Matrix3.I();
             D.assert(descendants.Count >= 2);
-            for (int index = descendants.Count - 1; index > 0; index -= 1)
+            for (int index = descendants.Count - 1; index > 0; index -= 1) {
+            }
+
-        public string toString() => this.GetType() + "";
+        public string toString() {
+            return this.GetType() + "";
+        }
     }
 
     public class ShapeBorderTween : Tween<ShapeBorder> {
 
         public readonly Color shadowColor;
 
-        public override State createState() => new _MaterialInteriorState();
+        public override State createState() {
+            return new _MaterialInteriorState();
+        }
 
 
         public override void debugFillProperties(DiagnosticPropertiesBuilder description) {

Runtime/material/material_button.cs

 
         public readonly Widget child;
 
-        public bool enabled => this.onPressed != null;
+        public bool enabled {
+            get { return this.onPressed != null; }
+        }
 
         public readonly EdgeInsets padding;
 

Runtime/material/text_selection.cs

             new _MaterialTextSelectionControls();
     }
 
-    internal static class _TextSelectionUtils {
+    static class _TextSelectionUtils {
-    internal class _TextSelectionToolbar : StatelessWidget {
+    class _TextSelectionToolbar : StatelessWidget {
         public _TextSelectionToolbar(Key key = null, Action handleCut = null,
             Action handleCopy = null, Action handlePaste = null, Action handleSelectAll = null) : base(key: key) {
             this.handleCut = handleCut;
         }
     }
 
-    internal class _TextSelectionToolbarLayout : SingleChildLayoutDelegate {
+    class _TextSelectionToolbarLayout : SingleChildLayoutDelegate {
         internal _TextSelectionToolbarLayout(Size screenSize = null, Rect globalEditableRegion = null,
             Offset position = null) {
             this.screenSize = screenSize;
             double x = globalPosition.dx - childSize.width / 2.0;
             double y = globalPosition.dy - childSize.height;
 
-            if (x < _TextSelectionUtils._kToolbarScreenPadding)
+            if (x < _TextSelectionUtils._kToolbarScreenPadding) {
-            else if (x + childSize.width > this.screenSize.width - _TextSelectionUtils._kToolbarScreenPadding)
+            }
+            else if (x + childSize.width > this.screenSize.width - _TextSelectionUtils._kToolbarScreenPadding) {
+            }
-            if (y < _TextSelectionUtils._kToolbarScreenPadding)
+            if (y < _TextSelectionUtils._kToolbarScreenPadding) {
-            else if (y + childSize.height > this.screenSize.height - _TextSelectionUtils._kToolbarScreenPadding)
+            }
+            else if (y + childSize.height > this.screenSize.height - _TextSelectionUtils._kToolbarScreenPadding) {
+            }
 
             return new Offset(x, y);
         }
         }
     }
 
-    internal class _TextSelectionHandlePainter : CustomPainter {
+    class _TextSelectionHandlePainter : CustomPainter {
         internal _TextSelectionHandlePainter(Color color) {
             this.color = color;
         }
         }
     }
 
-    internal class _MaterialTextSelectionControls : TextSelectionControls {
+    class _MaterialTextSelectionControls : TextSelectionControls {
-            get => new Size(_TextSelectionUtils._kHandleSize,
-                _TextSelectionUtils._kHandleSize);
+            get {
+                return new Size(_TextSelectionUtils._kHandleSize,
+                    _TextSelectionUtils._kHandleSize);
+            }
         }
 
         public override Widget buildToolbar(BuildContext context, Rect globalEditableRegion, Offset position,

Runtime/material/text_theme.cs

         }
 
         public TextTheme merge(TextTheme other) {
-            if (other == null)
+            if (other == null) {
+            }
+
             return this.copyWith(
                 display4: this.display4?.merge(other.display4) ?? other.display4,
                 display3: this.display3?.merge(other.display3) ?? other.display3,
         public static TextTheme lerp(TextTheme a, TextTheme b, double t) {
             D.assert(a != null);
             D.assert(b != null);
-            D.assert(t != null);
             return new TextTheme(
                 display4: TextStyle.lerp(a.display4, b.display4, t),
                 display3: TextStyle.lerp(a.display3, b.display3, t),

Runtime/material/theme.cs

             _InheritedTheme inheritedTheme =
                 (_InheritedTheme) context.inheritFromWidgetOfExactType(typeof(_InheritedTheme));
             if (shadowThemeOnly) {
-                if (inheritedTheme == null || inheritedTheme.theme.isMaterialAppTheme)
+                if (inheritedTheme == null || inheritedTheme.theme.isMaterialAppTheme) {
+                }
+
                 return inheritedTheme.theme.data;
             }
 
 
         public readonly Theme theme;
 
-        public override bool updateShouldNotify(InheritedWidget old) =>
-            this.theme.data != ((_InheritedTheme) old).theme.data;
+        public override bool updateShouldNotify(InheritedWidget old) {
+            return this.theme.data != ((_InheritedTheme) old).theme.data;
+        }
     }
 
     class ThemeDataTween : Tween<ThemeData> {
         ) : base(begin: begin, end: end) {
         }
 
-        public override ThemeData lerp(double t) => ThemeData.lerp(this.begin, this.end, t);
+        public override ThemeData lerp(double t) {
+            return ThemeData.lerp(this.begin, this.end, t);
+        }
     }
 
     class AnimatedTheme : ImplicitlyAnimatedWidget {
 
         public readonly Widget child;
 
-        public override State createState() => new _AnimatedThemeState();
+        public override State createState() {
+            return new _AnimatedThemeState();
+        }
     }
 
 

Runtime/material/theme_data.cs

             IconThemeData iconTheme,
             IconThemeData primaryIconTheme,
             IconThemeData accentIconTheme,
-            MaterialTapTargetSize materialTapTargetSize,
+            MaterialTapTargetSize? materialTapTargetSize,
             ColorScheme colorScheme,
             Typography typography
         ) {
                 typography: typography);
         }
 
-        public static ThemeData light() => new ThemeData(brightness: Brightness.light);
+        public static ThemeData light() {
+            return new ThemeData(brightness: Brightness.light);
+        }
-        public static ThemeData dark() => new ThemeData(brightness: Brightness.dark);
+        public static ThemeData dark() {
+            return new ThemeData(brightness: Brightness.dark);
+        }
-        public static ThemeData fallback() => light();
+        public static ThemeData fallback() {
+            return light();
+        }
 
 
         public readonly Brightness brightness;
         public static Brightness estimateBrightnessForColor(Color color) {
             double relativeLuminance = color.computeLuminance();
             double kThreshold = 0.15;
-            if ((relativeLuminance + 0.05) * (relativeLuminance + 0.05) > kThreshold)
+            if ((relativeLuminance + 0.05) * (relativeLuminance + 0.05) > kThreshold) {
+            }
+
             return Brightness.dark;
         }
 

Runtime/material/utils.cs

                 return rectCallback;
             }
 
-            if (containedInkWell)
+            if (containedInkWell) {
+            }
+
             return null;
         }
 

Runtime/painting/text_style.cs

             D.assert(this.fontWeight != null || fontWeightDelta == 0.0);
             D.assert(this.letterSpacing != null || (letterSpacingFactor == 1.0 && letterSpacingDelta == 0.0));
             D.assert(this.wordSpacing != null || (wordSpacingFactor == 1.0 && wordSpacingDelta == 0.0));
-            D.assert(heightFactor != null || (heightFactor == 1.0 && heightDelta == 0.0));
+            D.assert(this.height != null || (heightFactor == 1.0 && heightDelta == 0.0));
 
             string modifiedDebugLabel = "";
             D.assert(() => {
         }
 
         public static TextStyle lerp(TextStyle a, TextStyle b, double t) {
-            D.assert(t != null);
             D.assert(a == null || b == null || a.inherit == b.inherit);
             if (a == null && b == null) {
                 return null;

Runtime/service/system_chrome.cs

             );
         }
 
-        public int GetHashCode() {
+        public override int GetHashCode() {
             var hashCode = this.systemNavigationBarColor.GetHashCode();
             hashCode = (hashCode * 397) ^ this.systemNavigationBarDividerColor.GetHashCode();
             hashCode = (hashCode * 397) ^ this.statusBarColor.GetHashCode();

UIWidgetCleanupPlugin.DotSettings

 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeStyle/CodeCleanup/Profiles/=UIWidgets/@EntryIndexedValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;Profile name="UIWidgets"&gt;&lt;JsReformatCode&gt;True&lt;/JsReformatCode&gt;&lt;CSCodeStyleAttributes ArrangeTypeAccessModifier="True" ArrangeTypeMemberAccessModifier="True" SortModifiers="False" RemoveRedundantParentheses="False" AddMissingParentheses="True" ArrangeBraces="False" ArrangeAttributes="False" ArrangeArgumentsStyle="False" ArrangeCodeBodyStyle="False" ArrangeVarStyle="False" /&gt;&lt;CSOptimizeUsings&gt;&lt;OptimizeUsings&gt;True&lt;/OptimizeUsings&gt;&lt;EmbraceInRegion&gt;False&lt;/EmbraceInRegion&gt;&lt;RegionName&gt;&lt;/RegionName&gt;&lt;/CSOptimizeUsings&gt;&lt;CSReformatCode&gt;True&lt;/CSReformatCode&gt;&lt;CSFixBuiltinTypeReferences&gt;True&lt;/CSFixBuiltinTypeReferences&gt;&lt;CSArrangeQualifiers&gt;True&lt;/CSArrangeQualifiers&gt;&lt;CSShortenReferences&gt;True&lt;/CSShortenReferences&gt;&lt;IDEA_SETTINGS&gt;&amp;lt;profile version="1.0"&amp;gt;
+	<s:String x:Key="/Default/CodeStyle/CodeCleanup/Profiles/=UIWidgets/@EntryIndexedValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;Profile name="UIWidgets"&gt;&lt;JsReformatCode&gt;True&lt;/JsReformatCode&gt;&lt;CSCodeStyleAttributes ArrangeTypeAccessModifier="True" ArrangeTypeMemberAccessModifier="True" SortModifiers="False" RemoveRedundantParentheses="False" AddMissingParentheses="True" ArrangeBraces="True" ArrangeAttributes="False" ArrangeArgumentsStyle="False" ArrangeCodeBodyStyle="True" ArrangeVarStyle="False" /&gt;&lt;CSOptimizeUsings&gt;&lt;OptimizeUsings&gt;True&lt;/OptimizeUsings&gt;&lt;EmbraceInRegion&gt;False&lt;/EmbraceInRegion&gt;&lt;RegionName&gt;&lt;/RegionName&gt;&lt;/CSOptimizeUsings&gt;&lt;CSReformatCode&gt;True&lt;/CSReformatCode&gt;&lt;CSFixBuiltinTypeReferences&gt;True&lt;/CSFixBuiltinTypeReferences&gt;&lt;CSArrangeQualifiers&gt;True&lt;/CSArrangeQualifiers&gt;&lt;CSShortenReferences&gt;True&lt;/CSShortenReferences&gt;&lt;IDEA_SETTINGS&gt;&amp;lt;profile version="1.0"&amp;gt;
   &amp;lt;option name="myName" value="UIWidgets" /&amp;gt;
   &amp;lt;inspection_tool class="ES6ShorthandObjectProperty" enabled="false" level="INFORMATION" enabled_by_default="false" /&amp;gt;
   &amp;lt;inspection_tool class="JSArrowFunctionBracesCanBeRemoved" enabled="false" level="INFORMATION" enabled_by_default="false" /&amp;gt;