Use null aware operators to clean up code

pkg/analysis_server/lib/src/computer/computer_outline.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 computer.outline;
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/collections.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 23 matching lines @@
         for (ClassMember classMember in classDeclaration.members) {
           if (classMember is ConstructorDeclaration) {
             ConstructorDeclaration constructorDeclaration = classMember;
             classContents.add(_newConstructorOutline(constructorDeclaration));
           }
           if (classMember is FieldDeclaration) {
             FieldDeclaration fieldDeclaration = classMember;
             VariableDeclarationList fields = fieldDeclaration.fields;
             if (fields != null) {
               TypeName fieldType = fields.type;
-              String fieldTypeName =
-                  fieldType != null ? fieldType.toSource() : '';
+              String fieldTypeName = _safeToSource(fieldType);
               for (VariableDeclaration field in fields.variables) {
                 classContents.add(_newVariableOutline(fieldTypeName,
                     ElementKind.FIELD, field, fieldDeclaration.isStatic));
               }
             }
           }
           if (classMember is MethodDeclaration) {
             MethodDeclaration methodDeclaration = classMember;
             classContents.add(_newMethodOutline(methodDeclaration));
           }
         }
         unitContents.add(_newClassOutline(classDeclaration, classContents));
       }
       if (unitMember is EnumDeclaration) {
         EnumDeclaration enumDeclaration = unitMember;
         List<Outline> constantOutlines = <Outline>[];
         for (EnumConstantDeclaration constant in enumDeclaration.constants) {
           constantOutlines.add(_newEnumConstant(constant));
         }
         unitContents.add(_newEnumOutline(enumDeclaration, constantOutlines));
       }
       if (unitMember is TopLevelVariableDeclaration) {
         TopLevelVariableDeclaration fieldDeclaration = unitMember;
         VariableDeclarationList fields = fieldDeclaration.variables;
         if (fields != null) {
           TypeName fieldType = fields.type;
-          String fieldTypeName = fieldType != null ? fieldType.toSource() : '';
+          String fieldTypeName = _safeToSource(fieldType);
           for (VariableDeclaration field in fields.variables) {
             unitContents.add(_newVariableOutline(
                 fieldTypeName, ElementKind.TOP_LEVEL_VARIABLE, field, false));
           }
         }
       }
       if (unitMember is FunctionDeclaration) {
         FunctionDeclaration functionDeclaration = unitMember;
         unitContents.add(_newFunctionOutline(functionDeclaration, true));
       }
@@ skipping 117 matching lines @@
     bool isPrivate = false;
     if (constructorNameNode != null) {
       String constructorName = constructorNameNode.name;
       isPrivate = Identifier.isPrivateName(constructorName);
       name += '.$constructorName';
       offset = constructorNameNode.offset;
       length = constructorNameNode.length;
     }
     _SourceRegion sourceRegion = _getSourceRegion(constructor);
     FormalParameterList parameters = constructor.parameters;
-    String parametersStr = parameters != null ? parameters.toSource() : '';
+    String parametersStr = _safeToSource(parameters);
     Element element = new Element(
         ElementKind.CONSTRUCTOR,
         name,
         Element.makeFlags(
             isPrivate: isPrivate, isDeprecated: _isDeprecated(constructor)),
         location: _getLocationOffsetLength(offset, length),
         parameters: parametersStr);
     List<Outline> contents = _addLocalFunctionOutlines(constructor.body);
     Outline outline = new Outline(
         element, sourceRegion.offset, sourceRegion.length,
@@ skipping 38 matching lines @@
     FormalParameterList parameters = functionExpression.parameters;
     ElementKind kind;
     if (function.isGetter) {
       kind = ElementKind.GETTER;
     } else if (function.isSetter) {
       kind = ElementKind.SETTER;
     } else {
       kind = ElementKind.FUNCTION;
     }
     _SourceRegion sourceRegion = _getSourceRegion(function);
-    String parametersStr = parameters != null ? parameters.toSource() : '';
-    String returnTypeStr = returnType != null ? returnType.toSource() : '';
+    String parametersStr = _safeToSource(parameters);
+    String returnTypeStr = _safeToSource(returnType);
     Element element = new Element(
         kind,
         name,
         Element.makeFlags(
             isPrivate: Identifier.isPrivateName(name),
             isDeprecated: _isDeprecated(function),
             isStatic: isStatic),
         location: _getLocationNode(nameNode),
         parameters: parametersStr,
         returnType: returnTypeStr);
     List<Outline> contents = _addLocalFunctionOutlines(functionExpression.body);
     Outline outline = new Outline(
         element, sourceRegion.offset, sourceRegion.length,
         children: nullIfEmpty(contents));
     return outline;
   }
 
   Outline _newFunctionTypeAliasOutline(FunctionTypeAlias node) {
     TypeName returnType = node.returnType;
     SimpleIdentifier nameNode = node.name;
     String name = nameNode.name;
     _SourceRegion sourceRegion = _getSourceRegion(node);
     FormalParameterList parameters = node.parameters;
-    String parametersStr = parameters != null ? parameters.toSource() : '';
-    String returnTypeStr = returnType != null ? returnType.toSource() : '';
+    String parametersStr = _safeToSource(parameters);
+    String returnTypeStr = _safeToSource(returnType);
     Element element = new Element(
         ElementKind.FUNCTION_TYPE_ALIAS,
         name,
         Element.makeFlags(
             isPrivate: Identifier.isPrivateName(name),
             isDeprecated: _isDeprecated(node)),
         location: _getLocationNode(nameNode),
         parameters: parametersStr,
         returnType: returnTypeStr,
         typeParameters: _getTypeParametersStr(node.typeParameters));
     return new Outline(element, sourceRegion.offset, sourceRegion.length);
   }
 
   Outline _newMethodOutline(MethodDeclaration method) {
     TypeName returnType = method.returnType;
     SimpleIdentifier nameNode = method.name;
     String name = nameNode.name;
     FormalParameterList parameters = method.parameters;
     ElementKind kind;
     if (method.isGetter) {
       kind = ElementKind.GETTER;
     } else if (method.isSetter) {
       kind = ElementKind.SETTER;
     } else {
       kind = ElementKind.METHOD;
     }
     _SourceRegion sourceRegion = _getSourceRegion(method);
-    String parametersStr = parameters != null ? parameters.toSource() : null;
-    String returnTypeStr = returnType != null ? returnType.toSource() : '';
+    String parametersStr = parameters?.toSource();
+    String returnTypeStr = _safeToSource(returnType);
     Element element = new Element(
         kind,
         name,
         Element.makeFlags(
             isPrivate: Identifier.isPrivateName(name),
             isDeprecated: _isDeprecated(method),
             isAbstract: method.isAbstract,
             isStatic: method.isStatic),
         location: _getLocationNode(nameNode),
         parameters: parametersStr,
@@ skipping 41 matching lines @@
     return parameters.toSource();
   }
 
   /**
    * Returns `true` if the given [element] is not `null` and deprecated.
    */
   static bool _isDeprecated(Declaration declaration) {
     engine.Element element = declaration.element;
     return element != null && element.isDeprecated;
   }
+
+  static String _safeToSource(AstNode node) =>
+      node == null ? '' : node.toSource();

[scheglov, 2016/05/02 15:22:43]

node?.toSource() ?? ''

Not that it is much better, but just in case if you accidentally missed it.

[Brian Wilkerson, 2016/05/02 15:28:09]

Is that better? Looks to me like this would incur the cost of two null checks,
while the other only has one. Not that null checks are expensive, but...

[scheglov, 2016/05/02 15:29:57]

You're right, it isn't better.

 }
 
 /**
  * A visitor for building local function outlines.
  */
 class _LocalFunctionOutlinesVisitor extends RecursiveAstVisitor {
   final DartUnitOutlineComputer outlineComputer;
   final List<Outline> contents;
 
   _LocalFunctionOutlinesVisitor(this.outlineComputer, this.contents);
 
   @override
   visitFunctionDeclaration(FunctionDeclaration node) {
     contents.add(outlineComputer._newFunctionOutline(node, false));
   }
 }
 
 /**
  * A range of characters.
  */
 class _SourceRegion {
   final int length;
   final int offset;
   _SourceRegion(this.offset, this.length);
 }