Fix more strong mode errors in analyzer

pkg/analyzer/lib/src/dart/ast/ast.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.dart.ast.ast;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 7582 matching lines @@
 
 /**
  * A list of AST nodes that have a common parent.
  */
 class NodeListImpl<E extends AstNode> extends Object
     with ListMixin<E>
     implements NodeList<E> {
   /**
    * The node that is the parent of each of the elements in the list.
    */
-  @override
-  AstNodeImpl owner;
+  AstNodeImpl _owner;
 
   /**
    * The elements contained in the list.
    */
   List<E> _elements = <E>[];
 
   /**
    * Initialize a newly created list of nodes such that all of the nodes that
    * are added to the list will have their parent set to the given [owner]. The
    * list will initially be populated with the given [elements].
    */
-  NodeListImpl(this.owner, [List<E> elements]) {
+  NodeListImpl(this._owner, [List<E> elements]) {
     addAll(elements);
   }
 
   @override
   Token get beginToken {
     if (_elements.length == 0) {
       return null;
     }
     return _elements[0].beginToken;
   }
 
   @override
   Token get endToken {
     int length = _elements.length;
     if (length == 0) {
       return null;
     }
     return _elements[length - 1].endToken;
   }
 
   int get length => _elements.length;
 
   @deprecated // Never intended for public use.
   @override
   void set length(int newLength) {
     throw new UnsupportedError("Cannot resize NodeList.");
   }
 
+  @override
+  AstNode get owner => _owner;
+
+  @override
+  void set owner(AstNode value) {
+    _owner = value as AstNodeImpl;
+  }
+
   E operator [](int index) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
     return _elements[index];
   }
 
   void operator []=(int index, E node) {
     if (index < 0 || index >= _elements.length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
-    owner._becomeParentOf(node);
+    _owner._becomeParentOf(node);
     _elements[index] = node;
   }
 
   @override
   accept(AstVisitor visitor) {
     int length = _elements.length;
     for (var i = 0; i < length; i++) {
       _elements[i].accept(visitor);
     }
   }
 
   @override
   void add(E node) {
     insert(length, node);
   }
 
   @override
   bool addAll(Iterable<E> nodes) {
     if (nodes != null && !nodes.isEmpty) {
       _elements.addAll(nodes);
       for (E node in nodes) {
-        owner._becomeParentOf(node);
+        _owner._becomeParentOf(node);
       }
       return true;
     }
     return false;
   }
 
   @override
   void clear() {
     _elements = <E>[];
   }
 
   @override
   void insert(int index, E node) {
     int length = _elements.length;
     if (index < 0 || index > length) {
       throw new RangeError("Index: $index, Size: ${_elements.length}");
     }
-    owner._becomeParentOf(node);
+    _owner._becomeParentOf(node);
     if (length == 0) {
       _elements.add(node);
     } else {
       _elements.insert(index, node);
     }
   }
 
   @override
   E removeAt(int index) {
     if (index < 0 || index >= _elements.length) {
@@ skipping 3288 matching lines @@
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) =>
       visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _expression?.accept(visitor);
   }
 }