Java Visibility.PRIVATE属性代码示例

/**
 * Determines whether the given name is visible in the current context.
 * @param t The current traversal.
 * @param name The name node.
 */
private void checkNameVisibility(NodeTraversal t, Node name, Node parent) {
  Var var = t.getScope().getVar(name.getString());
  if (var != null) {
    JSDocInfo docInfo = var.getJSDocInfo();
    if (docInfo != null) {
      // If a name is private, make sure that we're in the same file.
      Visibility visibility = docInfo.getVisibility();
      if (visibility == Visibility.PRIVATE &&
          !t.getInput().getName().equals(docInfo.getSourceName())) {
        if (docInfo.isConstructor() &&
            isValidPrivateConstructorAccess(parent)) {
          return;
        }

        compiler.report(
            JSError.make(t, name, BAD_PRIVATE_GLOBAL_ACCESS,
                name.getString(), docInfo.getSourceName()));
      }
    }
  }
}
 

/**
 * Determines whether the given name is visible in the current context.
 * @param t The current traversal.
 * @param name The name node.
 */
private void checkNameVisibility(NodeTraversal t, Node name, Node parent) {
  Var var = t.getScope().getVar(name.getString());
  if (var != null) {
    JSDocInfo docInfo = var.getJSDocInfo();
    if (docInfo != null) {
      // If a name is private, make sure that we're in the same file.
      Visibility visibility = docInfo.getVisibility();
      if (visibility == Visibility.PRIVATE &&
          !t.getInput().getName().equals(docInfo.getSourceName())) {
        if (docInfo.isConstructor() &&
            isValidPrivateConstructorAccess(parent)) {
          return;
        }

        compiler.report(
            t.makeError(name, BAD_PRIVATE_GLOBAL_ACCESS,
                name.getString(), docInfo.getSourceName()));
      }
    }
  }
}
 

void maybeProcessAccessibilityModifier(ParseTree parseTree, Node n, @Nullable TokenType type) {
  if (type != null) {
    Visibility access;
    switch (type) {
      case PUBLIC:
        access = Visibility.PUBLIC;
        break;
      case PROTECTED:
        access = Visibility.PROTECTED;
        break;
      case PRIVATE:
        access = Visibility.PRIVATE;
        break;
      default:
        throw new IllegalStateException("Unexpected access modifier type");
    }
    maybeWarnTypeSyntax(parseTree, Feature.ACCESSIBILITY_MODIFIER);
    n.putProp(Node.ACCESS_MODIFIER, access);
  }
}
 

/**
 * Determines whether the given OBJECTLIT property visibility
 * violates the coding convention.
 * @param t The current traversal.
 * @param key The objectlit key node (STRING_KEY, GETTER_DEF, SETTER_DEF).
 */
private void checkKeyVisibilityConvention(NodeTraversal t,
    Node key, Node parent) {
  JSDocInfo info = key.getJSDocInfo();
  if (info == null) {
    return;
  }
  if (!isPrivateByConvention(key.getString())) {
    return;
  }
  Node assign = parent.getParent();
  if (assign == null || !assign.isAssign()) {
    return;
  }
  Node left = assign.getFirstChild();
  if (!left.isGetProp()
      || !left.getLastChild().getString().equals("prototype")) {
    return;
  }
  Visibility declaredVisibility = info.getVisibility();
  // Visibility is declared to be something other than private.
  if (declaredVisibility != Visibility.INHERITED
      && declaredVisibility != Visibility.PRIVATE) {
    compiler.report(t.makeError(key, CONVENTION_MISMATCH));
  }
}
 

@Override
protected boolean visitConstructor(FunctionType constructor) {
  Method constructorMethod = Method.newConstructor();
  if (constructor.getJSDocInfo().getVisibility() == Visibility.PRIVATE) {
    constructorMethod.setAccessModifier(AccessModifier.PRIVATE);
  }

  getCurrentJavaType().addMethod(constructorMethod);

  currentJavaMethodDeque.push(constructorMethod);
  return true;
}
 

/**
 * Determines whether the given name is visible in the current context.
 * @param t The current traversal.
 * @param name The name node.
 */
private void checkNameVisibility(NodeTraversal t, Node name, Node parent) {
  Var var = t.getScope().getVar(name.getString());
  if (var != null) {
    JSDocInfo docInfo = var.getJSDocInfo();
    if (docInfo != null) {
      // If a name is private, make sure that we're in the same file.
      Visibility visibility = docInfo.getVisibility();
      if (visibility == Visibility.PRIVATE) {
        StaticSourceFile varSrc = var.getSourceFile();
        StaticSourceFile refSrc = name.getStaticSourceFile();
        if (varSrc != null &&
            refSrc != null &&
            !varSrc.getName().equals(refSrc.getName())) {
          if (docInfo.isConstructor() &&
              isValidPrivateConstructorAccess(parent)) {
            return;
          }

          compiler.report(
              t.makeError(name, BAD_PRIVATE_GLOBAL_ACCESS,
                  name.getString(), varSrc.getName()));
        }
      }
    }
  }
}
 

/**
 * Records that the {@link JSDocInfo} being built should have its
 * {@link JSDocInfo#isAbstract()} flag set to {@code true}.
 *
 * @return {@code true} if the flag was recorded and {@code false}
 * if it was already defined or it was incompatible with the existing flags
 */
public boolean recordAbstract() {
  if (!hasAnySingletonTypeTags()
      && !currentInfo.isInterface()
      && !currentInfo.isAbstract()
      && !currentInfo.isFinal()
      && currentInfo.getVisibility() != Visibility.PRIVATE) {
    currentInfo.setAbstract();
    populated = true;
    return true;
  }
  return false;
}
 

private boolean isPrivatePropDecl(Node n) {
  // TODO(johnlenz): add support private by convention property definitions without JSDoc.
  // TODO(johnlenz): add support for checking protected properties in final classes
  // TODO(johnlenz): add support for checking "package" properties when checking an entire
  // library.
  JSDocInfo info = NodeUtil.getBestJSDocInfo(n);
  return (info != null && info.getVisibility() == Visibility.PRIVATE);
}
 

/**
 * Returns the effective visibility of the given overridden property.
 * An overridden property inherits the visibility of the property it
 * overrides.
 */
private static Visibility getEffectiveVisibilityForOverriddenProperty(
    Visibility visibility,
    @Nullable Visibility fileOverviewVisibility,
    String propertyName,
    @Nullable CodingConvention codingConvention) {
  if (codingConvention != null && codingConvention.isPrivate(propertyName)) {
    return Visibility.PRIVATE;
  }
  return (fileOverviewVisibility != null
      && visibility == Visibility.INHERITED)
      ? fileOverviewVisibility
      : visibility;
}
 

/**
 * Returns the effective visibility of the given non-overridden property.
 * Non-overridden properties without an explicit visibility annotation
 * receive the default visibility declared in the file's {@code @fileoverview}
 * block, if one exists.
 */
private static Visibility getEffectiveVisibilityForNonOverriddenProperty(
    Node getprop,
    ObjectTypeI objectType,
    @Nullable Visibility fileOverviewVisibility,
    @Nullable CodingConvention codingConvention) {
  String propertyName = getprop.getLastChild().getString();
  if (codingConvention != null && codingConvention.isPrivate(propertyName)) {
    return Visibility.PRIVATE;
  }
  Visibility raw = Visibility.INHERITED;
  if (objectType != null) {
    raw = objectType.getOwnPropertyJSDocInfo(propertyName).getVisibility();
  }
  TypeI type = getprop.getTypeI();
  boolean createdFromGoogProvide = (type != null && type.isLiteralObject());
  // Ignore @fileoverview visibility when computing the effective visibility
  // for properties created by goog.provide.
  //
  // ProcessClosurePrimitives rewrites goog.provide()s as object literal
  // declarations, but the exact form depends on the ordering of the
  // input files. If goog.provide('a.b.c') occurs in the inputs before
  // goog.provide('a'), it is rewritten like
  //
  // var a={};a.b={}a.b.c={};
  //
  // If the file containing goog.provide('a.b.c') also declares
  // a @fileoverview visibility, it must not apply to b, as this would make
  // every a.b.* namespace effectively package-private.
  return (raw != Visibility.INHERITED
      || fileOverviewVisibility == null
      || createdFromGoogProvide)
      ? raw
      : fileOverviewVisibility;
}
 

/**
 * Returns the effective visibility of the given name, reporting an error
 * if there is a contradiction in the various sources of visibility
 * (example: a variable with a trailing underscore that is declared
 * {@code @public}).
 */
private Visibility checkPrivateNameConvention(Visibility v, Node name) {
  if (isPrivateByConvention(name.getString())) {
    if (v != Visibility.PRIVATE && v != Visibility.INHERITED) {
      compiler.report(JSError.make(name, CONVENTION_MISMATCH));
    }
    return Visibility.PRIVATE;
  }
  return v;
}
 

private static boolean propertyIsDeclaredButNotPrivate(Node getprop, Node parent) {
  // This is a declaration with JSDoc
  JSDocInfo info = NodeUtil.getBestJSDocInfo(getprop);
  if ((parent.isAssign() || parent.isExprResult())
      && parent.getFirstChild() == getprop
      && info != null) {
    Visibility declaredVisibility = info.getVisibility();
    if (declaredVisibility != Visibility.PRIVATE
    && declaredVisibility != Visibility.INHERITED) {
        return true;
    }
  }
  return false;
}
 

private void checkOverriddenPropertyVisibility(
    NodeTraversal t,
    Node getprop,
    Node parent,
    Visibility visibility,
    Visibility fileOverviewVisibility,
    ObjectTypeI objectType,
    boolean sameInput) {
  // Check an ASSIGN statement that's trying to override a property
  // on a superclass.
  JSDocInfo overridingInfo = parent.getJSDocInfo();
  Visibility overridingVisibility = overridingInfo == null
      ? Visibility.INHERITED
      : overridingInfo.getVisibility();

  // Check that:
  // (a) the property *can* be overridden,
  // (b) the visibility of the override is the same as the
  //     visibility of the original property,
  // (c) the visibility is explicitly redeclared if the override is in
  //     a file with default visibility in the @fileoverview block.
  if (visibility == Visibility.PRIVATE && !sameInput) {
    compiler.report(
        t.makeError(getprop, PRIVATE_OVERRIDE,
            objectType.toString()));
  } else if (overridingVisibility != Visibility.INHERITED
      && overridingVisibility != visibility
      && fileOverviewVisibility == null) {
    compiler.report(
        t.makeError(getprop, VISIBILITY_MISMATCH,
            visibility.name(), objectType.toString(),
            overridingVisibility.name()));
  }
}
 

/**
 * Returns a Matcher that matches against nodes that are declared {@code @private}.
 */
public static Matcher isPrivate() {
  return new Matcher() {
    @Override public boolean matches(Node node, NodeMetadata metadata) {
      JSDocInfo jsDoc = NodeUtil.getBestJSDocInfo(node);
      if (jsDoc != null) {
        return jsDoc.getVisibility() == Visibility.PRIVATE;
      }
      return false;
    }
  };
}
 

private boolean isPrivate(@Nullable JSDocInfo docInfo) {
  return docInfo != null && docInfo.getVisibility() == Visibility.PRIVATE;
}