# HG changeset patch # User lana # Date 1396398339 25200 # Node ID 41457833656f9d1d8c36928a4b19aeb0e325ad75 # Parent c826d05f1fb0773f6a28caa763307dd30d90d36e# Parent e9b2766ef89c7c06775ced890471dfc3baba338e Merge diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/javadoc/ClassDoc.java --- a/langtools/src/share/classes/com/sun/javadoc/ClassDoc.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/javadoc/ClassDoc.java Tue Apr 01 17:25:39 2014 -0700 @@ -75,15 +75,6 @@ boolean isExternalizable(); /** - * Return true if this class can be used as a target type of a lambda expression - * or method reference. - * - * @return true if this class can be used as a target type of a lambda expression - * or method reference. - */ - boolean isFunctionalInterface(); - - /** * Return the serialization methods for this class or * interface. * diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassWriterImpl.java --- a/langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassWriterImpl.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/doclets/formats/html/ClassWriterImpl.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2014, 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 @@ -29,6 +29,7 @@ import com.sun.javadoc.*; import com.sun.tools.javac.jvm.Profile; +import com.sun.tools.javadoc.RootDocImpl; import com.sun.tools.doclets.formats.html.markup.*; import com.sun.tools.doclets.internal.toolkit.*; import com.sun.tools.doclets.internal.toolkit.builders.*; @@ -528,7 +529,7 @@ * {@inheritDoc} */ public void addFunctionalInterfaceInfo (Content classInfoTree) { - if (classDoc.isFunctionalInterface()) { + if (isFunctionalInterface()) { Content dt = HtmlTree.DT(getResource("doclet.Functional_Interface")); Content dl = HtmlTree.DL(dt); Content dd = new HtmlTree(HtmlTag.DD); @@ -538,6 +539,19 @@ } } + public boolean isFunctionalInterface() { + if (configuration.root instanceof RootDocImpl) { + RootDocImpl root = (RootDocImpl) configuration.root; + AnnotationDesc[] annotationDescList = classDoc.annotations(); + for (AnnotationDesc annoDesc : annotationDescList) { + if (root.isFunctionalInterface(annoDesc)) { + return true; + } + } + } + return false; + } + /** * {@inheritDoc} */ diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java --- a/langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1998, 2014, 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 @@ -1443,7 +1443,8 @@ } } if (configuration.currentcd != containing) { - refMemName = containing.name() + "." + refMemName; + refMemName = (refMem instanceof ConstructorDoc) ? + refMemName : containing.name() + "." + refMemName; } if (refMem instanceof ExecutableMemberDoc) { if (refMemName.indexOf('(') < 0) { diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/code/Attribute.java --- a/langtools/src/share/classes/com/sun/tools/javac/code/Attribute.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Attribute.java Tue Apr 01 17:25:39 2014 -0700 @@ -141,6 +141,7 @@ * access this attribute. */ public final List> values; + public TypeAnnotationPosition position; private boolean synthesized = false; @@ -154,10 +155,67 @@ } public Compound(Type type, - List> values) { + List> values, + TypeAnnotationPosition position) { super(type); this.values = values; + this.position = position; } + + public Compound(Type type, + List> values) { + this(type, values, null); + } + + @Override + public TypeAnnotationPosition getPosition() { + if (hasUnknownPosition()) { + if (values.size() != 0) { + Name valueName = values.head.fst.name.table.names.value; + Pair res = getElemPair(valueName); + position = res == null ? null : res.snd.getPosition(); + } + } + return position; + } + + public boolean isContainerTypeCompound() { + if (isSynthesized() && values.size() == 1) + return getFirstEmbeddedTC() != null; + return false; + } + + private Compound getFirstEmbeddedTC() { + if (values.size() == 1) { + Pair val = values.get(0); + if (val.fst.getSimpleName().contentEquals("value") + && val.snd instanceof Array) { + Array arr = (Array) val.snd; + if (arr.values.length != 0 + && arr.values[0] instanceof Attribute.TypeCompound) + return (Attribute.TypeCompound) arr.values[0]; + } + } + return null; + } + + public boolean tryFixPosition() { + if (!isContainerTypeCompound()) + return false; + + Compound from = getFirstEmbeddedTC(); + if (from != null && from.position != null && + from.position.type != TargetType.UNKNOWN) { + position = from.position; + return true; + } + return false; + } + + public boolean hasUnknownPosition() { + return position.type == TargetType.UNKNOWN; + } + public void accept(Visitor v) { v.visitCompound(this); } /** @@ -215,16 +273,6 @@ return (DeclaredType) type; } - @Override - public TypeAnnotationPosition getPosition() { - if (values.size() != 0) { - Name valueName = values.head.fst.name.table.names.value; - Pair res = getElemPair(valueName); - return res == null ? null : res.snd.getPosition(); - } - return null; - } - public Map getElementValues() { Map valmap = new LinkedHashMap<>(); for (Pair value : values) @@ -234,62 +282,15 @@ } public static class TypeCompound extends Compound { - public TypeAnnotationPosition position; - public TypeCompound(Compound compound, - TypeAnnotationPosition position) { - this(compound.type, compound.values, position); - } - public TypeCompound(Type type, - List> values, - TypeAnnotationPosition position) { - super(type, values); - this.position = position; - } - - @Override - public TypeAnnotationPosition getPosition() { - if (hasUnknownPosition()) { - position = super.getPosition(); - } - return position; - } - - public boolean hasUnknownPosition() { - return position.type == TargetType.UNKNOWN; + TypeAnnotationPosition position) { + super(compound.type, compound.values, position); } - public boolean isContainerTypeCompound() { - if (isSynthesized() && values.size() == 1) - return getFirstEmbeddedTC() != null; - return false; - } - - private TypeCompound getFirstEmbeddedTC() { - if (values.size() == 1) { - Pair val = values.get(0); - if (val.fst.getSimpleName().contentEquals("value") - && val.snd instanceof Array) { - Array arr = (Array) val.snd; - if (arr.values.length != 0 - && arr.values[0] instanceof Attribute.TypeCompound) - return (Attribute.TypeCompound) arr.values[0]; - } - } - return null; - } - - public boolean tryFixPosition() { - if (!isContainerTypeCompound()) - return false; - - TypeCompound from = getFirstEmbeddedTC(); - if (from != null && from.position != null && - from.position.type != TargetType.UNKNOWN) { - position = from.position; - return true; - } - return false; + public TypeCompound(Type type, + List> values, + TypeAnnotationPosition position) { + super(type, values, position); } } diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/code/Source.java --- a/langtools/src/share/classes/com/sun/tools/javac/code/Source.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/code/Source.java Tue Apr 01 17:25:39 2014 -0700 @@ -219,6 +219,9 @@ public boolean allowTypeAnnotations() { return compareTo(JDK1_8) >= 0; } + public boolean allowAnnotationsAfterTypeParams() { + return compareTo(JDK1_8) >= 0; + } public boolean allowRepeatedAnnotations() { return compareTo(JDK1_8) >= 0; } diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/comp/Check.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java Tue Apr 01 17:25:39 2014 -0700 @@ -1625,7 +1625,7 @@ protection(m.flags()) > protection(other.flags())) { log.error(TreeInfo.diagnosticPositionFor(m, tree), "override.weaker.access", cannotOverride(m, other), - other.flags() == 0 ? + (other.flags() & AccessFlags) == 0 ? "package" : asFlagSet(other.flags() & AccessFlags)); m.flags_field |= BAD_OVERRIDE; diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java --- a/langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/comp/Lower.java Tue Apr 01 17:25:39 2014 -0700 @@ -2919,15 +2919,65 @@ // constant propagation would require that we take care to // preserve possible side-effects in the condition expression. + // One common case is equality expressions involving a constant and null. + // Since null is not a constant expression (because null cannot be + // represented in the constant pool), equality checks involving null are + // not captured by Flow.isTrue/isFalse. + // Equality checks involving a constant and null, e.g. + // "" == null + // are safe to simplify as no side-effects can occur. + + private boolean isTrue(JCTree exp) { + if (exp.type.isTrue()) + return true; + Boolean b = expValue(exp); + return b == null ? false : b; + } + private boolean isFalse(JCTree exp) { + if (exp.type.isFalse()) + return true; + Boolean b = expValue(exp); + return b == null ? false : !b; + } + /* look for (in)equality relations involving null. + * return true - if expression is always true + * false - if expression is always false + * null - if expression cannot be eliminated + */ + private Boolean expValue(JCTree exp) { + while (exp.hasTag(PARENS)) + exp = ((JCParens)exp).expr; + + boolean eq; + switch (exp.getTag()) { + case EQ: eq = true; break; + case NE: eq = false; break; + default: + return null; + } + + // we have a JCBinary(EQ|NE) + // check if we have two literals (constants or null) + JCBinary b = (JCBinary)exp; + if (b.lhs.type.hasTag(BOT)) return expValueIsNull(eq, b.rhs); + if (b.rhs.type.hasTag(BOT)) return expValueIsNull(eq, b.lhs); + return null; + } + private Boolean expValueIsNull(boolean eq, JCTree t) { + if (t.type.hasTag(BOT)) return Boolean.valueOf(eq); + if (t.hasTag(LITERAL)) return Boolean.valueOf(!eq); + return null; + } + /** Visitor method for conditional expressions. */ @Override public void visitConditional(JCConditional tree) { JCTree cond = tree.cond = translate(tree.cond, syms.booleanType); - if (cond.type.isTrue()) { + if (isTrue(cond)) { result = convert(translate(tree.truepart, tree.type), tree.type); addPrunedInfo(cond); - } else if (cond.type.isFalse()) { + } else if (isFalse(cond)) { result = convert(translate(tree.falsepart, tree.type), tree.type); addPrunedInfo(cond); } else { @@ -2951,10 +3001,10 @@ */ public void visitIf(JCIf tree) { JCTree cond = tree.cond = translate(tree.cond, syms.booleanType); - if (cond.type.isTrue()) { + if (isTrue(cond)) { result = translate(tree.thenpart); addPrunedInfo(cond); - } else if (cond.type.isFalse()) { + } else if (isFalse(cond)) { if (tree.elsepart != null) { result = translate(tree.elsepart); } else { @@ -3333,21 +3383,21 @@ JCTree lhs = tree.lhs = translate(tree.lhs, formals.head); switch (tree.getTag()) { case OR: - if (lhs.type.isTrue()) { + if (isTrue(lhs)) { result = lhs; return; } - if (lhs.type.isFalse()) { + if (isFalse(lhs)) { result = translate(tree.rhs, formals.tail.head); return; } break; case AND: - if (lhs.type.isFalse()) { + if (isFalse(lhs)) { result = lhs; return; } - if (lhs.type.isTrue()) { + if (isTrue(lhs)) { result = translate(tree.rhs, formals.tail.head); return; } diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java --- a/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java Tue Apr 01 17:25:39 2014 -0700 @@ -2501,6 +2501,8 @@ return; } catch (IOException ex) { throw badClassFile("unable.to.access.file", ex.getMessage()); + } catch (ArrayIndexOutOfBoundsException ex) { + throw badClassFile("bad.class.file", c.flatname); } finally { currentClassFile = previousClassFile; } diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/main/Main.java --- a/langtools/src/share/classes/com/sun/tools/javac/main/Main.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/main/Main.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2014, 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 @@ -506,6 +506,11 @@ } } + if (options.get(XSTDOUT) != null) { + // Stdout reassigned - ask compiler to close it when it is done + comp.closeables = comp.closeables.prepend(log.getWriter(WriterKind.NOTICE)); + } + fileManager = context.get(JavaFileManager.class); if (!files.isEmpty()) { diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/main/Option.java --- a/langtools/src/share/classes/com/sun/tools/javac/main/Option.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/main/Option.java Tue Apr 01 17:25:39 2014 -0700 @@ -399,7 +399,6 @@ public boolean process(OptionHelper helper, String option, String arg) { try { Log log = helper.getLog(); - // TODO: this file should be closed at the end of compilation log.setWriters(new PrintWriter(new FileWriter(arg), true)); } catch (java.io.IOException e) { helper.error("err.error.writing.file", arg, e); diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java --- a/langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/parser/JavacParser.java Tue Apr 01 17:25:39 2014 -0700 @@ -161,6 +161,7 @@ this.allowStaticInterfaceMethods = source.allowStaticInterfaceMethods(); this.allowIntersectionTypesInCast = source.allowIntersectionTypesInCast(); this.allowTypeAnnotations = source.allowTypeAnnotations(); + this.allowAnnotationsAfterTypeParams = source.allowAnnotationsAfterTypeParams(); this.keepDocComments = keepDocComments; docComments = newDocCommentTable(keepDocComments, fac); this.keepLineMap = keepLineMap; @@ -254,6 +255,10 @@ */ boolean allowTypeAnnotations; + /** Switch: should we allow annotations after the method type parameters? + */ + boolean allowAnnotationsAfterTypeParams; + /** Switch: is "this" allowed as an identifier? * This is needed to parse receiver types. */ @@ -2026,7 +2031,7 @@ /** Creator = [Annotations] Qualident [TypeArguments] ( ArrayCreatorRest | ClassCreatorRest ) */ JCExpression creator(int newpos, List typeArgs) { - List newAnnotations = annotationsOpt(Tag.ANNOTATION); + List newAnnotations = typeAnnotationsOpt(); switch (token.kind) { case BYTE: case SHORT: case CHAR: case INT: case LONG: case FLOAT: @@ -3464,6 +3469,7 @@ nextToken(); } else { if (annosAfterParams.nonEmpty()) { + checkAnnotationsAfterTypeParams(annosAfterParams.head.pos); mods.annotations = mods.annotations.appendList(annosAfterParams); if (mods.pos == Position.NOPOS) mods.pos = mods.annotations.head.pos; @@ -4063,6 +4069,12 @@ allowTypeAnnotations = true; } } + void checkAnnotationsAfterTypeParams(int pos) { + if (!allowAnnotationsAfterTypeParams) { + log.error(pos, "annotations.after.type.params.not.supported.in.source", source.name); + allowAnnotationsAfterTypeParams = true; + } + } /* * a functional source tree and end position mappings diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java --- a/langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java Tue Apr 01 17:25:39 2014 -0700 @@ -761,14 +761,14 @@ public Set visitType(TypeElement e, Set p) { // Type parameters are not considered to be enclosed by a type scan(e.getTypeParameters(), p); - return scan(e.getEnclosedElements(), p); + return super.visitType(e, p); } @Override public Set visitExecutable(ExecutableElement e, Set p) { // Type parameters are not considered to be enclosed by an executable scan(e.getTypeParameters(), p); - return scan(e.getEnclosedElements(), p); + return super.visitExecutable(e, p); } void addAnnotations(Element e, Set p) { diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/processing/JavacRoundEnvironment.java --- a/langtools/src/share/classes/com/sun/tools/javac/processing/JavacRoundEnvironment.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/processing/JavacRoundEnvironment.java Tue Apr 01 17:25:39 2014 -0700 @@ -137,14 +137,14 @@ public Set visitType(TypeElement e, TypeElement p) { // Type parameters are not considered to be enclosed by a type scan(e.getTypeParameters(), p); - return scan(e.getEnclosedElements(), p); + return super.visitType(e, p); } @Override public Set visitExecutable(ExecutableElement e, TypeElement p) { // Type parameters are not considered to be enclosed by an executable scan(e.getTypeParameters(), p); - return scan(e.getEnclosedElements(), p); + return super.visitExecutable(e, p); } @Override diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties --- a/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties Tue Apr 01 17:25:39 2014 -0700 @@ -1709,6 +1709,10 @@ cannot access {0}\n\ {1} +# 0: class name +compiler.misc.bad.class.file=\ + class file is invalid for class {0} + # 0: file name, 1: message segment compiler.misc.bad.class.file.header=\ bad class file: {0}\n\ @@ -2321,6 +2325,11 @@ (use -source 8 or higher to enable type annotations) # 0: string +compiler.err.annotations.after.type.params.not.supported.in.source=\ + annotations after method type parameters are not supported in -source {0}\n\ +(use -source 8 or higher to enable annotations after method type parameters) + +# 0: string compiler.err.repeatable.annotations.not.supported.in.source=\ repeated annotations are not supported in -source {0}\n\ (use -source 8 or higher to enable repeated annotations) diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java --- a/langtools/src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javadoc/ClassDocImpl.java Tue Apr 01 17:25:39 2014 -0700 @@ -288,10 +288,6 @@ return false; } - public boolean isFunctionalInterface() { - return env.types.isFunctionalInterface(tsym) && env.source.allowLambda(); - } - /** * Return the package that this class is contained in. */ diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javadoc/RootDocImpl.java --- a/langtools/src/share/classes/com/sun/tools/javadoc/RootDocImpl.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javadoc/RootDocImpl.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2014, 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 @@ -381,6 +381,11 @@ env.initDoclint(opts, customTagNames); } + public boolean isFunctionalInterface(AnnotationDesc annotationDesc) { + return annotationDesc.annotationType().qualifiedName().equals( + env.syms.functionalInterfaceType.toString()) && env.source.allowLambda(); + } + public boolean showTagMessages() { return env.showTagMessages(); } diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javadoc/SeeTagImpl.java --- a/langtools/src/share/classes/com/sun/tools/javadoc/SeeTagImpl.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javadoc/SeeTagImpl.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2014, 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 @@ -398,7 +398,8 @@ private MemberDoc findExecutableMember(String memName, String[] paramarr, ClassDoc referencedClass) { - if (memName.equals(referencedClass.name())) { + String className = referencedClass.name(); + if (memName.equals(className.substring(className.lastIndexOf(".") + 1))) { return ((ClassDocImpl)referencedClass).findConstructor(memName, paramarr); } else { // it's a method. diff -r c826d05f1fb0 -r 41457833656f langtools/src/share/classes/com/sun/tools/javap/ClassWriter.java --- a/langtools/src/share/classes/com/sun/tools/javap/ClassWriter.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/src/share/classes/com/sun/tools/javap/ClassWriter.java Tue Apr 01 17:25:39 2014 -0700 @@ -202,7 +202,6 @@ if (options.verbose) { println(); indent(+1); - attrWriter.write(cf, cf.attributes, constant_pool); println("minor version: " + cf.minor_version); println("major version: " + cf.major_version); writeList("flags: ", flags.getClassFlags(), "\n"); @@ -218,6 +217,10 @@ writeMethods(); indent(-1); println("}"); + + if (options.verbose) { + attrWriter.write(cf, cf.attributes, constant_pool); + } } // where class JavaTypePrinter implements Type.Visitor { diff -r c826d05f1fb0 -r 41457833656f langtools/test/com/sun/javadoc/testConstructors/TestConstructors.java --- a/langtools/test/com/sun/javadoc/testConstructors/TestConstructors.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/com/sun/javadoc/testConstructors/TestConstructors.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2014, 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 @@ -23,7 +23,7 @@ /* * @test - * @bug 8025524 + * @bug 8025524 8031625 * @summary Test for constructor name which should be a non-qualified name. * @author Bhavesh Patel * @library ../lib/ @@ -38,6 +38,21 @@ //Input for string search tests. private static final String[][] TEST = { {BUG_ID + FS + "pkg1" + FS + "Outer.html", + "
See Also:
" + NL + + "
Inner(), " + NL + + "Inner(int), " + NL + + "NestedInner(), " + NL + + "NestedInner(int), " + NL + + "Outer(), " + NL + + "Outer(int)" + }, + {BUG_ID + FS + "pkg1" + FS + "Outer.html", + "Link: Inner(), " + + "Outer(int), " + + "" + + "NestedInner(int)" + }, + {BUG_ID + FS + "pkg1" + FS + "Outer.html", "Outer()" }, {BUG_ID + FS + "pkg1" + FS + "Outer.html", @@ -87,6 +102,18 @@ }, {BUG_ID + FS + "pkg1" + FS + "Outer.Inner.NestedInner.html", "Outer.Inner.NestedInner-int-" + }, + {BUG_ID + FS + "pkg1" + FS + "Outer.html", + "Outer.Inner()" + }, + {BUG_ID + FS + "pkg1" + FS + "Outer.html", + "Outer.Inner(int)" + }, + {BUG_ID + FS + "pkg1" + FS + "Outer.html", + "Outer.Inner.NestedInner()" + }, + {BUG_ID + FS + "pkg1" + FS + "Outer.html", + "Outer.Inner.NestedInner(int)" } }; diff -r c826d05f1fb0 -r 41457833656f langtools/test/com/sun/javadoc/testConstructors/pkg1/Outer.java --- a/langtools/test/com/sun/javadoc/testConstructors/pkg1/Outer.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/com/sun/javadoc/testConstructors/pkg1/Outer.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2013, 2014, 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 @@ -23,6 +23,17 @@ package pkg1; +/** + * Test link tag. + * Link: {@link pkg1.Outer.Inner#Inner()}, {@link pkg1.Outer#Outer(int)}, {@link pkg1.Outer.Inner.NestedInner#NestedInner(int)} + * + * @see Outer.Inner#Inner() + * @see Outer.Inner#Inner(int) + * @see Outer.Inner.NestedInner#NestedInner() + * @see Outer.Inner.NestedInner#NestedInner(int) + * @see Outer#Outer() + * @see Outer#Outer(int) + */ public class Outer { /** diff -r c826d05f1fb0 -r 41457833656f langtools/test/com/sun/javadoc/testLambdaFeature/TestLambdaFeature.java --- a/langtools/test/com/sun/javadoc/testLambdaFeature/TestLambdaFeature.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/com/sun/javadoc/testLambdaFeature/TestLambdaFeature.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2014, 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 @@ -23,7 +23,7 @@ /* * @test - * @bug 8004893 8022738 + * @bug 8004893 8022738 8029143 * @summary Make sure that the lambda feature changes work fine in * javadoc. * @author bpatel @@ -87,6 +87,11 @@ "
default default void defaultMethod()
"}, {BUG_ID + FS + "pkg" + FS + "B.html", "default void"}, + {BUG_ID + FS + "pkg1" + FS + "NotAFuncInf.html", + "
" + NL + "
Functional Interface:
" + NL + + "
This is a functional interface and can therefore be used as " + + "the assignment target for a lambda expression or method " + + "reference.
" + NL + "
"}, {BUG_ID + FS + "pkg" + FS + "B.html", "
" + NL + "
Functional Interface:
"} }; diff -r c826d05f1fb0 -r 41457833656f langtools/test/com/sun/javadoc/testLambdaFeature/pkg/A.java --- a/langtools/test/com/sun/javadoc/testLambdaFeature/pkg/A.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/com/sun/javadoc/testLambdaFeature/pkg/A.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2014, 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 @@ -23,6 +23,7 @@ package pkg; +@FunctionalInterface public interface A { public void method1(); diff -r c826d05f1fb0 -r 41457833656f langtools/test/com/sun/javadoc/testLambdaFeature/pkg1/FuncInf.java --- a/langtools/test/com/sun/javadoc/testLambdaFeature/pkg1/FuncInf.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/com/sun/javadoc/testLambdaFeature/pkg1/FuncInf.java Tue Apr 01 17:25:39 2014 -0700 @@ -23,6 +23,7 @@ package pkg1; +@FunctionalInterface public interface FuncInf { V call() throws Exception; diff -r c826d05f1fb0 -r 41457833656f langtools/test/com/sun/javadoc/testLambdaFeature/pkg1/NotAFuncInf.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/com/sun/javadoc/testLambdaFeature/pkg1/NotAFuncInf.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package pkg1; + +public interface NotAFuncInf { + + V call() throws Exception; +} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/ConstFoldTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/ConstFoldTest.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8025505 + * @summary Constant folding deficiency + * @library /tools/javac/lib + * @build ToolBox + * @run main ConstFoldTest + */ + +import java.net.URL; +import java.util.List; + +public class ConstFoldTest { + public static void main(String... args) throws Exception { + new ConstFoldTest().run(); + } + + // This is the test case. This class should end up + // as straight-line code with no conditionals + class CFTest { + void m() { + int x; + if (1 != 2) x=1; else x=0; + if (1 == 2) x=1; else x=0; + if ("" != null) x=1; else x=0; + if ("" == null) x=1; else x=0; + if (null == null) x=1; else x=0; + if (null != null) x=1; else x=0; + + x = 1 != 2 ? 1 : 0; + x = 1 == 2 ? 1 : 0; + x = "" != null ? 1 : 0; + x = "" == null ? 1 : 0; + x = null == null ? 1 : 0; + x = null != null ? 1 : 0; + + boolean b; + b = 1 != 2 && true; + b = 1 == 2 || true; + b = ("" != null) && true; + b = ("" == null) || true; + b = (null == null) && true; + b = (null != null) || true; + } + } + + // All of the conditionals above should be eliminated. + // these if* bytecodes should not be seen + final String regex = "\\sif(?:null|nonnull|eq|ne){1}\\s"; + + void run() throws Exception { + URL url = ConstFoldTest.class.getResource("ConstFoldTest$CFTest.class"); + String result = ToolBox.javap(new ToolBox.JavaToolArgs().setAllArgs("-c", url.getFile())); + System.out.println(result); + + List bad_codes = ToolBox.grep(regex, result, "\n"); + if (!bad_codes.isEmpty()) { + for (String code : bad_codes) + System.out.println("Bad OpCode Found: " + code); + throw new Exception("constant folding failed"); + } + } +} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/OverrideChecks/IncompleteMessageOverride.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/OverrideChecks/IncompleteMessageOverride.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,16 @@ +/* + * @test /nodynamiccopyright/ + * @bug 8035956 + * @summary javac, incomplete error message + * @author kizune + * + * @run compile/fail/ref=IncompleteMessageOverride.out -XDrawDiagnostics IncompleteMessageOverride.java + */ + +class Super { + static void m() {} +} + +class Sub extends Super { + private static void m() {} +} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/OverrideChecks/IncompleteMessageOverride.out --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/OverrideChecks/IncompleteMessageOverride.out Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,2 @@ +IncompleteMessageOverride.java:15:25: compiler.err.override.weaker.access: (compiler.misc.cant.override: m(), Sub, m(), Super), package +1 error diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/StdoutCloseTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/StdoutCloseTest.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 7118295 + * @summary javac does not explicitly close -Xstdout file + * @run main StdoutCloseTest + */ + + +import com.sun.tools.javac.util.Log; +import com.sun.tools.javac.main.Main; + +import java.io.*; +import java.util.ArrayList; +import java.util.List; + +public class StdoutCloseTest { + + public static void main(String[] args) throws Exception { + new StdoutCloseTest().test(); + } + + static final String program = "public class Test {\n" + + " public boolean test() {\n" + + " int i;\n" + + " if (i > 0) return true;\n" + + " return false;\n" + + " }\n" + + "}\n"; + + public void test() throws Exception { + final String sourceName = "Test.java"; + final String outName = "Test.out"; + File source = new File(sourceName); + PrintWriter pw = new PrintWriter(source); + pw.write(program); + pw.flush(); + pw.close(); + + PrintWriter log = compileClass(sourceName, outName); + + File outFile = new File(outName); + if (!outFile.exists()) { + throw new Exception("Output file was not created!"); + } + if (!log.checkError()) { // will return true if the stream is still open + log.close(); // Close output PrintWriter manually + throw new Exception("Output file was still open!"); + } + } + + public PrintWriter compileClass(String src, String out) { + List options = new ArrayList<>(); + options.add("-Xstdout"); + options.add(out); + options.add(src); + + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + Main compiler = new Main("javac", pw); + compiler.compile(options.toArray(new String[options.size()])); + pw.flush(); + if (sw.getBuffer().length() > 0) { + System.err.println(sw.toString()); + } + return compiler.log.getWriter(Log.WriterKind.NOTICE); + } +} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.out --- a/langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.out Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/tools/javac/annotations/typeAnnotations/failures/CantAnnotateScoping.out Tue Apr 01 17:25:39 2014 -0700 @@ -6,6 +6,7 @@ CantAnnotateScoping.java:56:37: compiler.err.cant.type.annotate.scoping: @TA,@TA2 CantAnnotateScoping.java:40:14: compiler.err.cant.type.annotate.scoping.1: @TA CantAnnotateScoping.java:42:34: compiler.err.cant.type.annotate.scoping: @TA,@DA,@TA2 +CantAnnotateScoping.java:42:25: compiler.err.annotation.type.not.applicable CantAnnotateScoping.java:44:38: compiler.err.cant.type.annotate.scoping: @TA,@DA CantAnnotateScoping.java:44:34: compiler.err.annotation.type.not.applicable -10 errors \ No newline at end of file +11 errors diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/annotations/typeAnnotations/failures/CheckErrorsForSource7.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/annotations/typeAnnotations/failures/CheckErrorsForSource7.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,195 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/**@test + * @bug 8035890 + * @summary Verify that the parser correctly checks for source level 8 on the new places where + * annotations can appear in 8. + * @run main CheckErrorsForSource7 CheckErrorsForSource7.java + */ +import java.io.File; +import java.io.IOException; +import java.lang.annotation.ElementType; +import java.lang.annotation.Target; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import javax.tools.Diagnostic; +import javax.tools.DiagnosticCollector; +import javax.tools.JavaFileObject; +import javax.tools.SimpleJavaFileObject; +import com.sun.source.tree.AnnotationTree; +import com.sun.source.tree.CompilationUnitTree; +import com.sun.source.tree.IdentifierTree; +import com.sun.source.tree.Tree.Kind; +import com.sun.source.util.JavacTask; +import com.sun.source.util.TreePathScanner; +import com.sun.source.util.Trees; +import com.sun.tools.javac.api.JavacTool; +import com.sun.tools.javac.file.JavacFileManager; + +/**For each place where an annotation can syntactically appear with -source 8, but not with + * -source 7, this test verifies that an error is correctly emitted from the parser for + * the annotation for -source 7. This test first gathers the occurrences of @TA from + * the CheckErrorsForSource7Data class below, and then repeatedly removes all these annotations + * except one and checks the parser reports an expected error. This is needed as as the parser + * typically produces only one 'insufficient source level' error for each new feature used. + */ +public class CheckErrorsForSource7 { + public static void main(String... args) throws IOException, URISyntaxException { + new CheckErrorsForSource7().run(args); + } + + private void run(String... args) throws IOException, URISyntaxException { + //the first and only parameter must be the name of the file to be analyzed: + if (args.length != 1) throw new IllegalStateException("Must provide source file!"); + File testSrc = new File(System.getProperty("test.src")); + File testFile = new File(testSrc, args[0]); + if (!testFile.canRead()) throw new IllegalStateException("Cannot read the test source"); + JavacFileManager fm = JavacTool.create().getStandardFileManager(null, null, null); + + //gather spans of the @TA annotations into typeAnnotationSpans: + JavacTask task = JavacTool.create().getTask(null, + fm, + null, + Collections.emptyList(), + null, + fm.getJavaFileObjects(testFile)); + final Trees trees = Trees.instance(task); + final CompilationUnitTree cut = task.parse().iterator().next(); + final List typeAnnotationSpans = new ArrayList<>(); + + new TreePathScanner() { + @Override + public Void visitAnnotation(AnnotationTree node, Void p) { + if (node.getAnnotationType().getKind() == Kind.IDENTIFIER && + ((IdentifierTree) node.getAnnotationType()).getName().contentEquals("TA")) { + int start = (int) trees.getSourcePositions().getStartPosition(cut, node); + int end = (int) trees.getSourcePositions().getEndPosition(cut, node); + typeAnnotationSpans.add(new int[] {start, end}); + } + return null; + } + }.scan(cut, null); + + //sort the spans in the reverse order, to simplify removing them from the source: + Collections.sort(typeAnnotationSpans, new Comparator() { + @Override + public int compare(int[] o1, int[] o2) { + return o2[0] - o1[0]; + } + }); + + //verify the errors are produce correctly: + String originalSource = cut.getSourceFile().getCharContent(false).toString(); + + for (int[] toKeep : typeAnnotationSpans) { + //prepare updated source code by removing all the annotations except the toKeep one: + String updated = originalSource; + + for (int[] span : typeAnnotationSpans) { + if (span == toKeep) continue; + + updated = updated.substring(0, span[0]) + updated.substring(span[1]); + } + + //parse and verify: + JavaFileObject updatedFile = new TestFO(cut.getSourceFile().toUri(), updated); + DiagnosticCollector errors = new DiagnosticCollector<>(); + JavacTask task2 = JavacTool.create().getTask(null, + fm, + errors, + Arrays.asList("-source", "7"), + null, + Arrays.asList(updatedFile)); + task2.parse(); + + boolean found = false; + + for (Diagnostic d : errors.getDiagnostics()) { + if (d.getKind() == Diagnostic.Kind.ERROR && EXPECTED_ERRORS.contains(d.getCode())) { + if (found) { + throw new IllegalStateException("More than one expected error found."); + } + found = true; + } + } + + if (!found) + throw new IllegalStateException("Did not produce proper errors for: " + updated); + } + } + + static final Set EXPECTED_ERRORS = new HashSet<>(Arrays.asList( + "compiler.err.type.annotations.not.supported.in.source", + "compiler.err.annotations.after.type.params.not.supported.in.source" + )); + + class TestFO extends SimpleJavaFileObject { + private final String content; + public TestFO(URI uri, String content) { + super(uri, Kind.SOURCE); + this.content = content; + } + + @Override public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException { + return content; + } + + @Override public boolean isNameCompatible(String simpleName, Kind kind) { + return true; + } + } +} + +//data on which the source level check is verified: +class CheckErrorsForSource7Data { + @Target(ElementType.TYPE_USE) + @interface TA { } + + Object n1 = new @TA ArrayList<@TA String>(); + Object n2 = new @TA Object() {}; + Object [] @TA [] arr @TA[]; + @TA int @TA[] ret(Object obj) @TA[] throws @TA Exception { + this.<@TA String>ret(null); + Object c1 = new @TA String[1]; + + int val = obj instanceof @TA String ? ((@TA String) obj).length() : 0; + List<@TA ?> l; + return null; + } + void vararg(String @TA ... args) { } + + abstract class C<@TA T extends @TA Number & @TA Runnable> + extends @TA ArrayList<@TA String> + implements java.util. @TA Comparator<@TA T> { } + + interface I extends java.util. @TA Comparator<@TA String> { } + +} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/annotations/typeAnnotations/failures/common/arrays/DeclarationAnnotation.out --- a/langtools/test/tools/javac/annotations/typeAnnotations/failures/common/arrays/DeclarationAnnotation.out Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/tools/javac/annotations/typeAnnotations/failures/common/arrays/DeclarationAnnotation.out Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ +DeclarationAnnotation.java:13:21: compiler.err.annotation.type.not.applicable DeclarationAnnotation.java:10:21: compiler.err.annotation.type.not.applicable DeclarationAnnotation.java:11:21: compiler.err.annotation.type.not.applicable DeclarationAnnotation.java:12:21: compiler.err.annotation.type.not.applicable -DeclarationAnnotation.java:13:21: compiler.err.annotation.type.not.applicable 4 errors diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/classreader/BadClass.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/classreader/BadClass.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 6898851 + * @summary Compiling against this corrupt class file causes a stacktrace from javac + */ + +import java.io.File; +import java.io.FileWriter; +import java.io.StringWriter; +import java.io.PrintWriter; +import java.io.IOException; + +import com.sun.tools.classfile.ClassFile; +import com.sun.tools.classfile.ClassWriter; +import com.sun.tools.javac.Main; + +public class BadClass { + // Create and compile file containing body; return compiler output + static String makeClass(String dir, String filename, String body) throws IOException { + File file = new File(dir, filename); + try (FileWriter fw = new FileWriter(file)) { + fw.write(body); + } + + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + String args[] = { "-cp", dir, "-d", dir, "-XDrawDiagnostics", file.getPath() }; + Main.compile(args, pw); + pw.close(); + return sw.toString(); + } + + public static void main(String... args) throws Exception { + new File("d1").mkdir(); + new File("d2").mkdir(); + + // Step 1. build an empty class with an interface + makeClass("d1", "Empty.java", "abstract class Empty implements Readable {}"); + + // Step 2. Modify classfile to have invalid constant pool index + ClassFile cf = ClassFile.read(new File("d1","Empty.class")); + cf.interfaces[0] = cf.constant_pool.size() + 10; + ClassWriter cw = new ClassWriter(); + cw.write(cf, new File("d2","Empty.class")); + + // Step 3. Compile use of invalid class + String result = makeClass("d2", "EmptyUse.java", "class EmptyUse { Empty e; }"); + if (!result.contains("compiler.misc.bad.class.file")) { + System.out.println(result); + throw new Exception("test failed"); + } + } +} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/defaultMethods/static/hiding/InterfaceMethodHidingTest.java --- a/langtools/test/tools/javac/defaultMethods/static/hiding/InterfaceMethodHidingTest.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/tools/javac/defaultMethods/static/hiding/InterfaceMethodHidingTest.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2014, 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 @@ -26,6 +26,7 @@ * @bug 8005166 * @summary Add support for static interface methods * Smoke test for static interface method hiding + * @run main/timeout=600 InterfaceMethodHidingTest */ import com.sun.source.util.JavacTask; diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/diags/examples.not-yet.txt --- a/langtools/test/tools/javac/diags/examples.not-yet.txt Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/tools/javac/diags/examples.not-yet.txt Tue Apr 01 17:25:39 2014 -0700 @@ -111,3 +111,4 @@ compiler.warn.unknown.enum.constant.reason # in bad class file compiler.warn.override.equals.but.not.hashcode # when a class overrides equals but not hashCode method from Object compiler.warn.file.from.future # warning for future modification times on files +compiler.misc.bad.class.file # class file is malformed diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/diags/examples/AnnotationsAfterTypeParamsNotSupportedInSource.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/diags/examples/AnnotationsAfterTypeParamsNotSupportedInSource.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +// key: compiler.err.annotations.after.type.params.not.supported.in.source +// key: compiler.warn.source.no.bootclasspath +// options: -source 7 + +@interface Anno { } + +class AnnotationsAfterTypeParamsNotSupportedInSource { + @Anno int m() { + return 0; + } +} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/lambda/FunctionalInterfaceConversionTest.java --- a/langtools/test/tools/javac/lambda/FunctionalInterfaceConversionTest.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/tools/javac/lambda/FunctionalInterfaceConversionTest.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2012, 2014, 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 @@ -30,7 +30,7 @@ * @author Maurizio Cimadamore * @library ../lib * @build JavacTestingAbstractThreadedTest - * @run main/othervm FunctionalInterfaceConversionTest + * @run main/timeout=600/othervm FunctionalInterfaceConversionTest */ // use /othervm to avoid jtreg timeout issues (CODETOOLS-7900047) diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/processing/environment/ProcessingEnvAnnoDiscovery.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/processing/environment/ProcessingEnvAnnoDiscovery.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8038080 + * @summary make sure that all declaration annotations are discovered + * by the processing environment + * @library /tools/javac/lib + * @build JavacTestingAbstractProcessor ProcessingEnvAnnoDiscovery + * @compile/process -processor ProcessingEnvAnnoDiscovery ProcessingEnvAnnoDiscovery.java + */ + +import java.lang.annotation.*; +import java.util.Set; +import javax.annotation.processing.*; +import javax.lang.model.element.*; + +import com.sun.tools.javac.util.*; + +@ProcessingEnvAnnoDiscovery.Anno1 +public class ProcessingEnvAnnoDiscovery<@ProcessingEnvAnnoDiscovery.Anno4 T> + extends JavacTestingAbstractProcessor { + private int round = 0; + + public boolean process(Set annos, RoundEnvironment rEnv) { + if (round++ == 0) { + System.out.println(annos); + Assert.check(annos.contains(eltUtils.getTypeElement("java.lang.annotation.Target"))); + Assert.check(annos.contains(eltUtils.getTypeElement("ProcessingEnvAnnoDiscovery.Anno1"))); + Assert.check(annos.contains(eltUtils.getTypeElement("ProcessingEnvAnnoDiscovery.Anno2"))); + Assert.check(annos.contains(eltUtils.getTypeElement("ProcessingEnvAnnoDiscovery.Anno3"))); + Assert.check(annos.contains(eltUtils.getTypeElement("ProcessingEnvAnnoDiscovery.Anno4"))); + Assert.check(annos.contains(eltUtils.getTypeElement("ProcessingEnvAnnoDiscovery.Anno5"))); + Assert.check(annos.size() == 6, "Found extra annotations"); //Anno1-5 + @Target + } + + return true; + } + + @Anno2 + public <@Anno5 K> K m(@Anno3 long foo) { + return null; + } + + @interface Anno1 {} + + @interface Anno2 {} + + @interface Anno3 {} + + @Target(ElementType.TYPE_PARAMETER) + @interface Anno4 {} + + @Target(ElementType.TYPE_PARAMETER) + @interface Anno5 {} + +} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/processing/environment/round/Anno.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/processing/environment/round/Anno.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import java.lang.annotation.*; +import static java.lang.annotation.RetentionPolicy.*; + +@Retention(RUNTIME) +public @interface Anno {} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/processing/environment/round/ParameterAnnotations.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javac/processing/environment/round/ParameterAnnotations.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * Class to hold annotations for ElementsAnnotatedWithTest. + */ + +@AnnotatedElementInfo(annotationName="Anno", + expectedSize=1, + names={"annotatedParameter"}) +public class ParameterAnnotations { + private void foo(@Anno Object annotatedParameter) {} +} diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javac/processing/environment/round/TestElementsAnnotatedWith.java --- a/langtools/test/tools/javac/processing/environment/round/TestElementsAnnotatedWith.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/tools/javac/processing/environment/round/TestElementsAnnotatedWith.java Tue Apr 01 17:25:39 2014 -0700 @@ -23,7 +23,7 @@ /* * @test - * @bug 6397298 6400986 6425592 6449798 6453386 6508401 6498938 6911854 8030049 + * @bug 6397298 6400986 6425592 6449798 6453386 6508401 6498938 6911854 8030049 8038080 * @summary Tests that getElementsAnnotatedWith works properly. * @author Joseph D. Darcy * @library /tools/javac/lib @@ -31,12 +31,14 @@ * @compile TestElementsAnnotatedWith.java * @compile InheritedAnnotation.java * @compile TpAnno.java + * @compile Anno.java * @compile -processor TestElementsAnnotatedWith -proc:only SurfaceAnnotations.java * @compile -processor TestElementsAnnotatedWith -proc:only BuriedAnnotations.java * @compile -processor TestElementsAnnotatedWith -proc:only Part1.java Part2.java * @compile -processor TestElementsAnnotatedWith -proc:only C2.java * @compile -processor TestElementsAnnotatedWith -proc:only Foo.java * @compile -processor TestElementsAnnotatedWith -proc:only TypeParameterAnnotations.java + * @compile -processor TestElementsAnnotatedWith -proc:only ParameterAnnotations.java * @compile/fail/ref=ErroneousAnnotations.out -processor TestElementsAnnotatedWith -proc:only -XDrawDiagnostics ErroneousAnnotations.java * @compile Foo.java * @compile/process -processor TestElementsAnnotatedWith -proc:only Foo diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javap/T4975569.java --- a/langtools/test/tools/javap/T4975569.java Wed Jul 05 19:34:36 2017 +0200 +++ b/langtools/test/tools/javap/T4975569.java Tue Apr 01 17:25:39 2014 -0700 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2008, 2014, 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 @@ -40,10 +40,10 @@ verify("T4975569$Anno", "flags: ACC_INTERFACE, ACC_ABSTRACT, ACC_ANNOTATION"); verify("T4975569$E", "flags: ACC_FINAL, ACC_SUPER, ACC_ENUM"); verify("T4975569$S", "flags: ACC_BRIDGE, ACC_SYNTHETIC", - "InnerClasses:\n static"); + "InnerClasses:\n static"); verify("T4975569$V", "void m(java.lang.String...)", "flags: ACC_VARARGS"); - verify("T4975569$Prot", "InnerClasses:\n protected"); + verify("T4975569$Prot", "InnerClasses:\n protected"); //verify("T4975569$Priv", "InnerClasses"); if (errors > 0) throw new Error(errors + " found."); diff -r c826d05f1fb0 -r 41457833656f langtools/test/tools/javap/T8035104.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/langtools/test/tools/javap/T8035104.java Tue Apr 01 17:25:39 2014 -0700 @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2014, 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. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8035104 + * @summary reorder class file attributes in javap listing + */ + +import java.io.*; + +public class T8035104 { + public static void main(String[] args) throws Exception { + new T8035104().run(); + } + + public void run() throws Exception { + String[] lines = javap("-v", T8035104.class.getName()).split("[\r\n]+"); + int minor = -1; + int SourceFile = -1; + for (int i = 0; i < lines.length; i++) { + String line = lines[i]; + if (line.matches(" *minor version: [0-9.]+")) + minor = i; + if (line.matches(" *SourceFile: .+")) + SourceFile = i; + } + if (minor == -1) + throw new Exception("minor version not found"); + if (SourceFile == -1) + throw new Exception("SourceFile not found"); + if (SourceFile < minor) + throw new Exception("unexpected order of output"); + + System.out.println("output OK"); + } + + String javap(String... args) { + StringWriter sw = new StringWriter(); + PrintWriter out = new PrintWriter(sw); + int rc = com.sun.tools.javap.Main.run(args, out); + out.close(); + System.out.println(sw.toString()); + System.out.println("javap exited, rc=" + rc); + return sw.toString(); + } +}