Fixes for translator and DDA status files.

pkg/analyzer_experimental/lib/src/generated/resolver.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 1925 matching lines @@
     if (node.inSetterContext()) {
       String methodName = sc.TokenType.INDEX_EQ.lexeme;
       lookUpCheckIndexOperator(node, target, methodName, staticType, propagatedType);
     }
     return null;
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorElement invokedConstructor = node.constructorName.element;
     node.staticElement = invokedConstructor;
     node.element = invokedConstructor;
-    resolveArgumentsToParameters(node.isConst(), node.argumentList, invokedConstructor);
+    ArgumentList argumentList2 = node.argumentList;
+    List<ParameterElement> parameters = resolveArgumentsToParameters(node.isConst(), argumentList2, invokedConstructor);
+    if (parameters != null) {
+      argumentList2.correspondingStaticParameters = parameters;
+    }
     return null;
   }
   Object visitLibraryDirective(LibraryDirective node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier methodName2 = node.methodName;
     Expression target = node.realTarget;
     Element staticElement;
     Element propagatedElement;
     if (target is SuperExpression && !isSuperInValidContext((target as SuperExpression))) {
       return null;
     }
     if (target == null) {
       staticElement = resolveInvokedElement2(methodName2);
       propagatedElement = null;
     } else {
       Type2 targetType = getStaticType(target);
       staticElement = resolveInvokedElement(target, targetType, methodName2);
       propagatedElement = resolveInvokedElement(target, getPropagatedType(target), methodName2);
     }
     staticElement = convertSetterToGetter(staticElement);
     propagatedElement = convertSetterToGetter(propagatedElement);
-    Element recordedElement = recordResolution2(methodName2, staticElement, propagatedElement);
-    if (recordedElement is PropertyAccessorElement) {
-      FunctionType getterType = ((recordedElement as PropertyAccessorElement)).type;
-      if (getterType != null) {
-        Type2 getterReturnType = getterType.returnType;
-        if (getterReturnType is InterfaceType) {
-          MethodElement callMethod = ((getterReturnType as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
-          if (callMethod != null) {
-            resolveArgumentsToParameters(false, node.argumentList, callMethod);
-          }
-        } else if (getterReturnType is FunctionType) {
-          Element functionElement = ((getterReturnType as FunctionType)).element;
-          if (functionElement is ExecutableElement) {
-            resolveArgumentsToParameters(false, node.argumentList, (functionElement as ExecutableElement));
-          }
-        }
+    recordResolution2(methodName2, staticElement, propagatedElement);
+    ArgumentList argumentList2 = node.argumentList;
+    if (staticElement != null) {
+      List<ParameterElement> parameters = computePropagatedParameters(argumentList2, staticElement);
+      if (parameters != null) {
+        argumentList2.correspondingStaticParameters = parameters;
       }
-    } else if (recordedElement is ExecutableElement) {
-      resolveArgumentsToParameters(false, node.argumentList, (recordedElement as ExecutableElement));
-    } else if (recordedElement is VariableElement) {
-      VariableElement variable = recordedElement as VariableElement;
-      Type2 type2 = variable.type;
-      if (type2 is FunctionType) {
-        FunctionType functionType = type2 as FunctionType;
-        List<ParameterElement> parameters2 = functionType.parameters;
-        resolveArgumentsToParameters2(false, node.argumentList, parameters2);
-      } else if (type2 is InterfaceType) {
-        MethodElement callMethod = ((type2 as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
-        if (callMethod != null) {
-          List<ParameterElement> parameters3 = callMethod.parameters;
-          resolveArgumentsToParameters2(false, node.argumentList, parameters3);
-        }
+    }
+    if (propagatedElement != null) {
+      List<ParameterElement> parameters = computePropagatedParameters(argumentList2, propagatedElement);
+      if (parameters != null) {
+        argumentList2.correspondingParameters = parameters;
       }
     }
     ErrorCode errorCode;
     if (staticElement == null) {
       if (propagatedElement == null) {
         errorCode = checkForInvocationError(target, staticElement);
       } else {
         errorCode = checkForInvocationError(target, propagatedElement);
       }
     } else {
@@ skipping 116 matching lines @@
       element = enclosingClass2.getNamedConstructor(name.name);
     }
     if (element == null) {
       return null;
     }
     if (name != null) {
       recordResolution(name, element);
     }
     node.staticElement = element;
     node.element = element;
-    resolveArgumentsToParameters(false, node.argumentList, element);
+    ArgumentList argumentList2 = node.argumentList;
+    List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList2, element);
+    if (parameters != null) {
+      argumentList2.correspondingStaticParameters = parameters;
+    }
     return null;
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.element != null) {
       return null;
     }
     Element element = resolveSimpleIdentifier(node);
     if (isFactoryConstructorReturnType(node) && element != _resolver.enclosingClass) {
       _resolver.reportError(CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS, node, []);
     } else if (element == null) {
@@ skipping 32 matching lines @@
     } else {
       if (element.isFactory()) {
         _resolver.reportError(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       recordResolution(name, element);
     }
     node.staticElement = element;
     node.element = element;
-    resolveArgumentsToParameters(false, node.argumentList, element);
+    ArgumentList argumentList2 = node.argumentList;
+    List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList2, element);
+    if (parameters != null) {
+      argumentList2.correspondingStaticParameters = parameters;
+    }
     return null;
   }
   Object visitSuperExpression(SuperExpression node) {
     if (!isSuperInValidContext(node)) {
       _resolver.reportError(CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, node, []);
     }
     return super.visitSuperExpression(node);
   }
   Object visitTypeParameter(TypeParameter node) {
     TypeName bound2 = node.bound;
@@ skipping 111 matching lines @@
    * "noSuchMethod"
    */
   bool classDeclaresNoSuchMethod2(Element element) {
     if (element is ClassElement) {
       return classDeclaresNoSuchMethod((element as ClassElement));
     }
     return false;
   }
 
   /**
+   * Given a list of arguments and the element that will be invoked using those argument, compute
+   * the list of parameters that correspond to the list of arguments. Return the parameters that
+   * correspond to the arguments, or {@code null} if no correspondence could be computed.
+   * @param argumentList the list of arguments being passed to the element
+   * @param executableElement the element that will be invoked with the arguments
+   * @return the parameters that correspond to the arguments
+   */
+  List<ParameterElement> computePropagatedParameters(ArgumentList argumentList, Element element2) {
+    if (element2 is PropertyAccessorElement) {
+      FunctionType getterType = ((element2 as PropertyAccessorElement)).type;
+      if (getterType != null) {
+        Type2 getterReturnType = getterType.returnType;
+        if (getterReturnType is InterfaceType) {
+          MethodElement callMethod = ((getterReturnType as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
+          if (callMethod != null) {
+            return resolveArgumentsToParameters(false, argumentList, callMethod);
+          }
+        } else if (getterReturnType is FunctionType) {
+          Element functionElement = ((getterReturnType as FunctionType)).element;
+          if (functionElement is ExecutableElement) {
+            return resolveArgumentsToParameters(false, argumentList, (functionElement as ExecutableElement));
+          }
+        }
+      }
+    } else if (element2 is ExecutableElement) {
+      return resolveArgumentsToParameters(false, argumentList, (element2 as ExecutableElement));
+    } else if (element2 is VariableElement) {
+      VariableElement variable = element2 as VariableElement;
+      Type2 type2 = variable.type;
+      if (type2 is FunctionType) {
+        FunctionType functionType = type2 as FunctionType;
+        List<ParameterElement> parameters2 = functionType.parameters;
+        return resolveArgumentsToParameters2(false, argumentList, parameters2);
+      } else if (type2 is InterfaceType) {
+        MethodElement callMethod = ((type2 as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
+        if (callMethod != null) {
+          List<ParameterElement> parameters3 = callMethod.parameters;
+          return resolveArgumentsToParameters2(false, argumentList, parameters3);
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
    * If the given element is a setter, return the getter associated with it. Otherwise, return the
    * element unchanged.
    * @param element the element to be normalized
    * @return a non-setter element derived from the given element
    */
   Element convertSetterToGetter(Element element) {
     if (element is PropertyAccessorElement) {
       return ((element as PropertyAccessorElement)).variable.getter;
     }
     return element;
@@ skipping 201 matching lines @@
       if (getter != null) {
         return getter;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       PropertyAccessorElement getter = lookUpGetterInInterfaces(interfaceType, true, getterName, visitedInterfaces);
       if (getter != null) {
         return getter;
       }
     }
+    for (InterfaceType mixinType in targetType.mixins) {
+      PropertyAccessorElement getter = lookUpGetterInInterfaces(mixinType, true, getterName, visitedInterfaces);
+      if (getter != null) {
+        return getter;
+      }
+    }
     InterfaceType superclass2 = targetType.superclass;
     if (superclass2 == null) {
       return null;
     }
     return lookUpGetterInInterfaces(superclass2, true, getterName, visitedInterfaces);
   }
 
   /**
    * Look up the method or getter with the given name in the given type. Return the element
    * representing the method or getter that was found, or {@code null} if there is no method or
@@ skipping 45 matching lines @@
       if (member != null) {
         return member;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       ExecutableElement member = lookUpGetterOrMethodInInterfaces(interfaceType, true, memberName, visitedInterfaces);
       if (member != null) {
         return member;
       }
     }
+    for (InterfaceType mixinType in targetType.mixins) {
+      ExecutableElement member = lookUpGetterOrMethodInInterfaces(mixinType, true, memberName, visitedInterfaces);
+      if (member != null) {
+        return member;
+      }
+    }
     InterfaceType superclass2 = targetType.superclass;
     if (superclass2 == null) {
       return null;
     }
     return lookUpGetterOrMethodInInterfaces(superclass2, true, memberName, visitedInterfaces);
   }
 
   /**
    * Find the element corresponding to the given label node in the current label scope.
    * @param parentNode the node containing the given label
@@ skipping 80 matching lines @@
       if (method != null) {
         return method;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       MethodElement method = lookUpMethodInInterfaces(interfaceType, true, methodName, visitedInterfaces);
       if (method != null) {
         return method;
       }
     }
+    for (InterfaceType mixinType in targetType.mixins) {
+      MethodElement method = lookUpMethodInInterfaces(mixinType, true, methodName, visitedInterfaces);
+      if (method != null) {
+        return method;
+      }
+    }
     InterfaceType superclass2 = targetType.superclass;
     if (superclass2 == null) {
       return null;
     }
     return lookUpMethodInInterfaces(superclass2, true, methodName, visitedInterfaces);
   }
 
   /**
    * Look up the setter with the given name in the given type. Return the element representing the
    * setter that was found, or {@code null} if there is no setter with the given name.
@@ skipping 41 matching lines @@
       if (setter != null) {
         return setter;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       PropertyAccessorElement setter = lookUpSetterInInterfaces(interfaceType, true, setterName, visitedInterfaces);
       if (setter != null) {
         return setter;
       }
     }
+    for (InterfaceType mixinType in targetType.mixins) {
+      PropertyAccessorElement setter = lookUpSetterInInterfaces(mixinType, true, setterName, visitedInterfaces);
+      if (setter != null) {
+        return setter;
+      }
+    }
     InterfaceType superclass2 = targetType.superclass;
     if (superclass2 == null) {
       return null;
     }
     return lookUpSetterInInterfaces(superclass2, true, setterName, visitedInterfaces);
   }
 
   /**
    * Return the binary operator that is invoked by the given compound assignment operator.
    * @param operator the assignment operator being mapped
@@ skipping 42 matching lines @@
 
   /**
    * Record the fact that the given AST node was resolved to the given elements.
    * @param node the AST node that was resolved
    * @param staticElement the element to which the AST node was resolved using static type
    * information
    * @param propagatedElement the element to which the AST node was resolved using propagated type
    * information
    * @return the element that was associated with the node
    */
-  Element recordResolution2(SimpleIdentifier node, Element staticElement2, Element propagatedElement) {
+  void recordResolution2(SimpleIdentifier node, Element staticElement2, Element propagatedElement) {
     node.staticElement = staticElement2;
-    Element element = propagatedElement == null ? staticElement2 : propagatedElement;
-    node.element = element;
-    return element;
+    node.element = propagatedElement == null ? staticElement2 : propagatedElement;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
-   * the list of parameters that correspond to the list of arguments.
+   * the list of parameters that correspond to the list of arguments. Return the parameters that
+   * correspond to the arguments, or {@code null} if no correspondence could be computed.
    * @param reportError if {@code true} then compile-time error should be reported; if {@code false}then compile-time warning
    * @param argumentList the list of arguments being passed to the element
    * @param executableElement the element that will be invoked with the arguments
+   * @return the parameters that correspond to the arguments
    */
-  void resolveArgumentsToParameters(bool reportError, ArgumentList argumentList, ExecutableElement executableElement) {
+  List<ParameterElement> resolveArgumentsToParameters(bool reportError, ArgumentList argumentList, ExecutableElement executableElement) {
     if (executableElement == null) {
-      return;
+      return null;
     }
     List<ParameterElement> parameters2 = executableElement.parameters;
-    resolveArgumentsToParameters2(reportError, argumentList, parameters2);
+    return resolveArgumentsToParameters2(reportError, argumentList, parameters2);
   }
 
   /**
-   * Given a list of arguments and the element that will be invoked using those argument, compute
-   * the list of parameters that correspond to the list of arguments.
+   * Given a list of arguments and the parameters related to the element that will be invoked using
+   * those argument, compute the list of parameters that correspond to the list of arguments. Return
+   * the parameters that correspond to the arguments.
    * @param reportError if {@code true} then compile-time error should be reported; if {@code false}then compile-time warning
    * @param argumentList the list of arguments being passed to the element
    * @param parameters the of the function that will be invoked with the arguments
+   * @return the parameters that correspond to the arguments
    */
-  void resolveArgumentsToParameters2(bool reportError2, ArgumentList argumentList, List<ParameterElement> parameters) {
+  List<ParameterElement> resolveArgumentsToParameters2(bool reportError2, ArgumentList argumentList, List<ParameterElement> parameters) {
     List<ParameterElement> requiredParameters = new List<ParameterElement>();
     List<ParameterElement> positionalParameters = new List<ParameterElement>();
     Map<String, ParameterElement> namedParameters = new Map<String, ParameterElement>();
     for (ParameterElement parameter in parameters) {
       ParameterKind kind = parameter.parameterKind;
       if (identical(kind, ParameterKind.REQUIRED)) {
         requiredParameters.add(parameter);
       } else if (identical(kind, ParameterKind.POSITIONAL)) {
         positionalParameters.add(parameter);
       } else {
@@ skipping 32 matching lines @@
         }
       }
     }
     if (positionalArgumentCount < requiredParameters.length) {
       ErrorCode errorCode = reportError2 ? CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS : StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS;
       _resolver.reportError(errorCode, argumentList, [requiredParameters.length, positionalArgumentCount]);
     } else if (positionalArgumentCount > unnamedParameterCount) {
       ErrorCode errorCode = reportError2 ? CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS : StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS;
       _resolver.reportError(errorCode, argumentList, [unnamedParameterCount, positionalArgumentCount]);
     }
-    argumentList.correspondingParameters = resolvedParameters;
+    return resolvedParameters;
   }
 
   /**
    * Resolve the names in the given combinators in the scope of the given library.
    * @param library the library that defines the names
    * @param combinators the combinators containing the names to be resolved
    */
   void resolveCombinators(LibraryElement library, NodeList<Combinator> combinators) {
     if (library == null) {
       return;
@@ skipping 95 matching lines @@
     Type2 staticType = getStaticType(target);
     ExecutableElement staticElement = resolveProperty(target, staticType, propertyName);
     propertyName.staticElement = staticElement;
     Type2 propagatedType = getPropagatedType(target);
     ExecutableElement propagatedElement = resolveProperty(target, propagatedType, propertyName);
     Element selectedElement = select2(staticElement, propagatedElement);
     propertyName.element = selectedElement;
     if (shouldReportMissingMember(staticType, staticElement) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedElement))) {
       bool staticNoSuchMethod = staticType != null && classDeclaresNoSuchMethod2(staticType.element);
       bool propagatedNoSuchMethod = propagatedType != null && classDeclaresNoSuchMethod2(propagatedType.element);
-      if (!staticNoSuchMethod && !propagatedNoSuchMethod) {
+      if (!staticNoSuchMethod && (_strictMode || !propagatedNoSuchMethod)) {
         bool isStaticProperty = isStatic(selectedElement);
         if (propertyName.inSetterContext()) {
           if (isStaticProperty) {
             _resolver.reportError(StaticWarningCode.UNDEFINED_SETTER, propertyName, [propertyName.name, staticType.displayName]);
           } else {
             _resolver.reportError(StaticTypeWarningCode.UNDEFINED_SETTER, propertyName, [propertyName.name, staticType.displayName]);
           }
         } else if (propertyName.inGetterContext()) {
           if (isStaticProperty) {
             _resolver.reportError(StaticWarningCode.UNDEFINED_GETTER, propertyName, [propertyName.name, staticType.displayName]);
@@ skipping 5936 matching lines @@
   }
 
   /**
    * Hide all of the given names by removing them from the given collection of defined names.
    * @param definedNames the names that were defined before this operation
    * @param hiddenNames the names to be hidden
    */
   void hide(Map<String, Element> definedNames, List<String> hiddenNames) {
     for (String name in hiddenNames) {
       definedNames.remove(name);
+      definedNames.remove("${name}=");
     }
   }
 
   /**
    * Show only the given names by removing all other names from the given collection of defined
    * names.
    * @param definedNames the names that were defined before this operation
    * @param shownNames the names to be shown
    */
   Map<String, Element> show(Map<String, Element> definedNames, List<String> shownNames) {
     Map<String, Element> newNames = new Map<String, Element>();
     for (String name in shownNames) {
       Element element = definedNames[name];
       if (element != null) {
         newNames[name] = element;
       }
+      String setterName = "${name}=";
+      element = definedNames[setterName];
+      if (element != null) {
+        newNames[setterName] = element;
+      }
     }
     return newNames;
   }
 }
 /**
  * The abstract class {@code Scope} defines the behavior common to name scopes used by the resolver
  * to determine which names are visible at any given point in the code.
  * @coverage dart.engine.resolver
  */
 abstract class Scope {
@@ skipping 1322 matching lines @@
   /**
    * This verifies that the passed argument can be assigned to their corresponding parameters.
    * @param node the argument to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
   bool checkForArgumentTypeNotAssignable2(Expression argument) {
     if (argument == null) {
       return false;
     }
-    ParameterElement parameterElement2 = argument.parameterElement;
-    if (parameterElement2 == null) {
-      return false;
-    }
-    Type2 parameterType = parameterElement2.type;
-    if (parameterType == null) {
-      return false;
-    }
-    Type2 staticType = getStaticType(argument);
-    if (staticType == null) {
-      return false;
-    }
-    if (staticType.isAssignableTo(parameterType)) {
+    ParameterElement staticParameterElement2 = argument.staticParameterElement;
+    Type2 staticParameterType = staticParameterElement2 == null ? null : staticParameterElement2.type;
+    Type2 staticArgumentType = getStaticType(argument);
+    if (staticArgumentType == null || staticParameterType == null) {
       return false;
     }
     if (_strictMode) {
-      _errorReporter.reportError2(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, argument, [staticType.displayName, parameterType.displayName]);
+      if (staticArgumentType.isAssignableTo(staticParameterType)) {
+        return false;
+      }
+      _errorReporter.reportError2(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, argument, [staticArgumentType.displayName, staticParameterType.displayName]);
       return true;
     }
-    Type2 propagatedType = getPropagatedType(argument);
-    if (propagatedType != null && propagatedType.isAssignableTo(parameterType)) {
+    ParameterElement propagatedParameterElement = argument.parameterElement;
+    Type2 propagatedParameterType = propagatedParameterElement == null ? null : propagatedParameterElement.type;
+    Type2 propagatedArgumentType = getPropagatedType(argument);
+    if (propagatedArgumentType == null || propagatedParameterType == null) {
+      if (staticArgumentType.isAssignableTo(staticParameterType)) {
+        return false;
+      }
+      _errorReporter.reportError2(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, argument, [staticArgumentType.displayName, staticParameterType.displayName]);
+      return true;
+    }
+    if (staticArgumentType.isAssignableTo(staticParameterType) || staticArgumentType.isAssignableTo(propagatedParameterType) || propagatedArgumentType.isAssignableTo(staticParameterType) || propagatedArgumentType.isAssignableTo(propagatedParameterType)) {
       return false;
     }
-    _errorReporter.reportError2(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, argument, [(propagatedType == null ? staticType : propagatedType).displayName, parameterType.displayName]);
+    _errorReporter.reportError2(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, argument, [(propagatedArgumentType == null ? staticArgumentType : propagatedArgumentType).displayName, (propagatedParameterType == null ? staticParameterType : propagatedParameterType).displayName]);
     return true;
   }
 
   /**
    * This verifies that left hand side of the passed assignment expression is not final.
    * @param node the assignment expression to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ASSIGNMENT_TO_FINAL
    */
   bool checkForAssignmentToFinal(AssignmentExpression node) {
@@ skipping 2038 matching lines @@
 class PubVerifier extends RecursiveASTVisitor<Object> {
 
   /**
    * The error reporter by which errors will be reported.
    */
   ErrorReporter _errorReporter;
   PubVerifier(ErrorReporter errorReporter) {
     this._errorReporter = errorReporter;
   }
   Object visitImportDirective(ImportDirective directive) {
-//    StringLiteral uriLiteral = directive.uri;
-//    if (uriLiteral == null) {
-//      return null;
-//    }
-//    String uriContent = uriLiteral.stringValue;
-//    if (uriContent == null) {
-//      return null;
-//    }
-//    uriContent = uriContent.trim();
-//    int index = uriContent.indexOf(':');
-//    String scheme;
-//    String path;
-//    if (index > -1) {
-//      scheme = uriContent.substring(0, index);
-//      path = uriContent.substring(index + 1);
-//    } else {
-//      scheme = FileUriResolver.FILE_SCHEME;
-//      path = uriContent;
-//    }
-//    if (scheme == FileUriResolver.FILE_SCHEME) {
-//      if (checkForFileImportOutsideLibReferencesFileInside(directive, path)) {
-//        _errorReporter.reportError2(PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE, uriLiteral, []);
-//      } else if (checkForFileImportInsideLibReferencesFileOutside(directive, path)) {
-//        _errorReporter.reportError2(PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE, uriLiteral, []);
-//      }
-//    } else if (scheme == PackageUriResolver.PACKAGE_SCHEME) {
-//      if (checkForPackageImportContainsDotDot(path)) {
-//        _errorReporter.reportError2(PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT, uriLiteral, []);
-//      }
-//    }
     return null;
   }
 
   /**
    * Determine if the file file path lies inside the "lib" directory hierarchy but references a file
    * outside that directory hierarchy.
    * @param directive the import directive (not {@code null})
    * @param path the file path being verified (not {@code null})
    * @return {@code true} if the file is inside but references a file outside
    */
@@ skipping 42 matching lines @@
    */
   bool checkForPackageImportContainsDotDot(String path) => path.contains("/../");
 
   /**
    * Answer the full name of the source associated with the compilation unit containing the given
    * AST node. The returned value will have all {@link File#separatorChar} replace by '/'.
    * @param node the node (not {@code null})
    * @return the full name or {@code null} if it could not be determined
    */
   String getSourceFullName(ASTNode node) {
-//    CompilationUnit unit = node.getAncestor(CompilationUnit);
-//    if (unit != null) {
-//      CompilationUnitElement element2 = unit.element;
-//      if (element2 != null) {
-//        Source librarySource = element2.source;
-//        if (librarySource != null) {
-//          String fullName2 = librarySource.fullName;
-//          if (fullName2 != null) {
-//            return fullName2.replaceAll(JavaFile.separatorChar, '/');
-//          }
-//        }
-//      }
-//    }
+    CompilationUnit unit = node.getAncestor(CompilationUnit);
+    if (unit != null) {
+      CompilationUnitElement element2 = unit.element;
+      if (element2 != null) {
+        Source librarySource = element2.source;
+        if (librarySource != null) {
+          String fullName2 = librarySource.fullName;
+          if (fullName2 != null) {
+            return fullName2.replaceAll(r'\', '/');
+          }
+        }
+      }
+    }
     return null;
   }
 }
 /**
  * The enumeration {@code ResolverErrorCode} defines the error codes used for errors detected by the
  * resolver. The convention for this class is for the name of the error code to indicate the problem
  * that caused the error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
  * @coverage dart.engine.resolver
  */
@@ skipping 27 matching lines @@
   ResolverErrorCode(this.name, this.ordinal, ErrorType type, String message) {
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   int compareTo(ResolverErrorCode other) => ordinal - other.ordinal;
   String toString() => name;
 }