jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Check.java

-:9f42a06a49c0
+:df694c775e8a
 /*
-* Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 log.error(a.pos(), "method.does.not.override.superclass");
 }
 }
 /**
-* Validate the proposed container 'containedBy' on the
+* Validate the proposed container 'repeatable' on the
 * annotation type symbol 's'. Report errors at position
 * 'pos'.
 *
-* @param s The (annotation)type declaration annotated with a @ContainedBy
+* @param s The (annotation)type declaration annotated with a @Repeatable
-* @param containedBy the @ContainedBy on 's'
+* @param repeatable the @Repeatable on 's'
 * @param pos where to report errors
 */
-public void validateContainedBy(TypeSymbol s, Attribute.Compound containedBy, DiagnosticPosition pos) {
+public void validateRepeatable(TypeSymbol s, Attribute.Compound repeatable, DiagnosticPosition pos) {
-Assert.check(types.isSameType(containedBy.type, syms.containedByType));
+Assert.check(types.isSameType(repeatable.type, syms.repeatableType));
 Type t = null;
-List<Pair<MethodSymbol,Attribute>> l = containedBy.values;
+List<Pair<MethodSymbol,Attribute>> l = repeatable.values;
 if (!l.isEmpty()) {
 Assert.check(l.head.fst.name == names.value);
 t = ((Attribute.Class)l.head.snd).getValue();
 }
 if (t == null) {
-log.error(pos, "invalid.container.wrong.containedby", s, containedBy);
+// errors should already have been reported during Annotate
 return;
 }
-validateHasContainerFor(t.tsym, s, pos);
+validateValue(t.tsym, s, pos);
 validateRetention(t.tsym, s, pos);
 validateDocumented(t.tsym, s, pos);
 validateInherited(t.tsym, s, pos);
 validateTarget(t.tsym, s, pos);
 validateDefault(t.tsym, s, pos);
 }
-/**
+private void validateValue(TypeSymbol container, TypeSymbol contained, DiagnosticPosition pos) {
-* Validate the proposed container 'containerFor' on the
+Scope.Entry e = container.members().lookup(names.value);
-* annotation type symbol 's'. Report errors at position
+if (e.scope != null && e.sym.kind == MTH) {
-* 'pos'.
+MethodSymbol m = (MethodSymbol) e.sym;
-*
+Type ret = m.getReturnType();
-* @param s The (annotation)type declaration annotated with a @ContainerFor
+if (!(ret.hasTag(ARRAY) && types.isSameType(((ArrayType)ret).elemtype, contained.type))) {
-* @param containerFor the @ContainedFor on 's'
+log.error(pos, "invalid.repeatable.annotation.value.return",
-* @param pos where to report errors
+container, ret, types.makeArrayType(contained.type));
-*/
+}
-public void validateContainerFor(TypeSymbol s, Attribute.Compound containerFor, DiagnosticPosition pos) {
+} else {
-Assert.check(types.isSameType(containerFor.type, syms.containerForType));
+log.error(pos, "invalid.repeatable.annotation.no.value", container);
+}
-Type t = null;
-List<Pair<MethodSymbol,Attribute>> l = containerFor.values;
-if (!l.isEmpty()) {
-Assert.check(l.head.fst.name == names.value);
-t = ((Attribute.Class)l.head.snd).getValue();
-}
-if (t == null) {
-log.error(pos, "invalid.container.wrong.containerfor", s, containerFor);
-return;
-}
-validateHasContainedBy(t.tsym, s, pos);
-}
-private void validateHasContainedBy(TypeSymbol container, TypeSymbol contained, DiagnosticPosition pos) {
-Attribute.Compound containedBy = container.attribute(syms.containedByType.tsym);
-if (containedBy == null) {
-log.error(pos, "invalid.container.no.containedby", container, syms.containedByType.tsym);
-return;
-}
-Type t = null;
-List<Pair<MethodSymbol,Attribute>> l = containedBy.values;
-if (!l.isEmpty()) {
-Assert.check(l.head.fst.name == names.value);
-t = ((Attribute.Class)l.head.snd).getValue();
-}
-if (t == null) {
-log.error(pos, "invalid.container.wrong.containedby", container, contained);
-return;
-}
-if (!types.isSameType(t, contained.type))
-log.error(pos, "invalid.container.wrong.containedby", t.tsym, contained);
-}
-private void validateHasContainerFor(TypeSymbol container, TypeSymbol contained, DiagnosticPosition pos) {
-Attribute.Compound containerFor = container.attribute(syms.containerForType.tsym);
-if (containerFor == null) {
-log.error(pos, "invalid.container.no.containerfor", container, syms.containerForType.tsym);
-return;
-}
-Type t = null;
-List<Pair<MethodSymbol,Attribute>> l = containerFor.values;
-if (!l.isEmpty()) {
-Assert.check(l.head.fst.name == names.value);
-t = ((Attribute.Class)l.head.snd).getValue();
-}
-if (t == null) {
-log.error(pos, "invalid.container.wrong.containerfor", container, contained);
-return;
-}
-if (!types.isSameType(t, contained.type))
-log.error(pos, "invalid.container.wrong.containerfor", t.tsym, contained);
 }
 private void validateRetention(Symbol container, Symbol contained, DiagnosticPosition pos) {
 Attribute.RetentionPolicy containerRetention = types.getRetention(container);
 Attribute.RetentionPolicy containedRetention = types.getRetention(contained);
 if (containerRetention == Attribute.RetentionPolicy.SOURCE)  {
 error = true;
 }
 }
 if (error ) {
-log.error(pos, "invalid.containedby.annotation.retention",
+log.error(pos, "invalid.repeatable.annotation.retention",
 container, containerRetention,
 contained, containedRetention);
 }
 }
 private void validateDocumented(Symbol container, Symbol contained, DiagnosticPosition pos) {
 if (contained.attribute(syms.documentedType.tsym) != null) {
 if (container.attribute(syms.documentedType.tsym) == null) {
-log.error(pos, "invalid.containedby.annotation.not.documented", container, contained);
+log.error(pos, "invalid.repeatable.annotation.not.documented", container, contained);
 }
 }
 }
 private void validateInherited(Symbol container, Symbol contained, DiagnosticPosition pos) {
 if (contained.attribute(syms.inheritedType.tsym) != null) {
 if (container.attribute(syms.inheritedType.tsym) == null) {
-log.error(pos, "invalid.containedby.annotation.not.inherited", container, contained);
+log.error(pos, "invalid.repeatable.annotation.not.inherited", container, contained);
 }
 }
 }
 private void validateTarget(Symbol container, Symbol contained, DiagnosticPosition pos) {
 // trivially true if contained has no target as per above).
 // contained has target, but container has not, error
 Attribute.Array containerTarget = getAttributeTargetAttribute(container);
 if (containerTarget == null) {
-log.error(pos, "invalid.containedby.annotation.incompatible.target", container, contained);
+log.error(pos, "invalid.repeatable.annotation.incompatible.target", container, contained);
 return;
 }
 Set<Name> containerTargets = new HashSet<Name>();
 for (Attribute app : containerTarget.values) {
 Attribute.Enum e = (Attribute.Enum)app;
 containedTargets.add(e.value.name);
 }
 if (!isTargetSubset(containedTargets, containerTargets)) {
-log.error(pos, "invalid.containedby.annotation.incompatible.target", container, contained);
+log.error(pos, "invalid.repeatable.annotation.incompatible.target", container, contained);
 }
 }
 /** Checks that t is a subset of s, with respect to ElementType
 * semantics, specifically {ANNOTATION_TYPE} is a subset of {TYPE}
 for(Symbol elm : scope.getElements()) {
 if (elm.name != names.value &&
 elm.kind == Kinds.MTH &&
 ((MethodSymbol)elm).defaultValue == null) {
 log.error(pos,
-"invalid.containedby.annotation.elem.nondefault",
+"invalid.repeatable.annotation.elem.nondefault",
 container,
 elm);
 }
 }
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Check.java

src/share/classes/com/sun/tools/javac/comp/Check.java