[1.7, 1.8, 1.9 BACKPORT]: /hg/icedtea6: S6638712: Inference with wildcard types
Dr Andrew John Hughes
ahughes at redhat.com
Mon Sep 20 07:32:19 PDT 2010
Ok for 1.7, 1.8 and 1.9?
----- Forwarded message from andrew at icedtea.classpath.org -----
Date: Thu, 16 Sep 2010 23:12:05 +0000
From: andrew at icedtea.classpath.org
To: distro-pkg-dev at openjdk.java.net
Subject: /hg/icedtea6: S6638712: Inference with wildcard types causes sel...
changeset 63024b10e2ef in /hg/icedtea6
details: http://icedtea.classpath.org/hg/icedtea6?cmd=changeset;node=63024b10e2ef
author: Andrew John Hughes <ahughes at redhat.com>
date: Thu Sep 16 23:36:39 2010 +0100
S6638712: Inference with wildcard types causes selection of
inapplicable method S6650759: Inference of formal type parameter
(unused in formal parameters) is not performed
2010-09-09 Andrew John Hughes <ahughes at redhat.com>
* Makefile.am: Add new patches.
* NEWS: Document new patches. Fix key.
* patches/openjdk/6638712-wildcard_types.patch,
* patches/openjdk/6650759-missing_inference.patch: Fix failure
in javac compilation.
diffstat:
5 files changed, 1582 insertions(+), 3 deletions(-)
ChangeLog | 10
Makefile.am | 4
NEWS | 4
patches/openjdk/6638712-wildcard_types.patch | 669 +++++++++++++++++
patches/openjdk/6650759-missing_inference.patch | 898 +++++++++++++++++++++++
diffs (truncated from 1626 to 500 lines):
diff -r a1ccc755c8f7 -r 63024b10e2ef ChangeLog
--- a/ChangeLog Thu Sep 16 14:53:19 2010 -0400
+++ b/ChangeLog Thu Sep 16 23:36:39 2010 +0100
@@ -1,4 +1,12 @@ 2010-09-16 Deepak Bhole <dbhole at redhat.c
-2010-09-16 Deepak Bhole <dbhole at redhat.com>
+2010-09-09 Andrew John Hughes <ahughes at redhat.com>
+
+ * Makefile.am: Add new patches.
+ * NEWS: Document new patches. Fix key.
+ * patches/openjdk/6638712-wildcard_types.patch,
+ * patches/openjdk/6650759-missing_inference.patch:
+ Fix failure in javac compilation.
+
+2010-09-16 Deepak Bhole <dbhole at redhat.com>
* plugin/icedteanp/java/sun/applet/PluginAppletViewer.java
(handleMessage): Output initialization info only in debug mode.
diff -r a1ccc755c8f7 -r 63024b10e2ef Makefile.am
--- a/Makefile.am Thu Sep 16 14:53:19 2010 -0400
+++ b/Makefile.am Thu Sep 16 23:36:39 2010 +0100
@@ -295,7 +295,9 @@ ICEDTEA_PATCHES = \
patches/icedtea-too-many-args.patch \
patches/icedtea-jtreg-OpenGLContextInit.patch \
patches/openjdk/6969395-net_bugs.patch \
- patches/openjdk/6510892-httpserver_test.patch
+ patches/openjdk/6510892-httpserver_test.patch \
+ patches/openjdk/6638712-wildcard_types.patch \
+ patches/openjdk/6650759-missing_inference.patch
if WITH_RHINO
ICEDTEA_PATCHES += \
diff -r a1ccc755c8f7 -r 63024b10e2ef NEWS
--- a/NEWS Thu Sep 16 14:53:19 2010 -0400
+++ b/NEWS Thu Sep 16 23:36:39 2010 +0100
@@ -1,6 +1,6 @@ Key:
Key:
-SX - http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6969395
+SX - http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=X
PRX - http://icedtea.classpath.org/bugzilla/show_bug.cgi?id=X
RHX - https://bugzilla.redhat.com/show_bug.cgi?id=X
DX - http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=X
@@ -14,6 +14,8 @@ New in release 1.10 (2010-XX-XX):
- S4356282, RH525870: RFE: T2K should be used to rasterize CID/CFF fonts
- S6954424: Support OpenType/CFF fonts in JDK 7
- S6438179: XToolkit.isTraySupported() result has nothing to do with the system tray
+ - S6638712: Inference with wildcard types causes selection of inapplicable method
+ - S6650759: Inference of formal type parameter (unused in formal parameters) is not performed
* Netx
- A new man page for javaws.
* Plugin
diff -r a1ccc755c8f7 -r 63024b10e2ef patches/openjdk/6638712-wildcard_types.patch
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/openjdk/6638712-wildcard_types.patch Thu Sep 16 23:36:39 2010 +0100
@@ -0,0 +1,669 @@
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Type.java openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Type.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Type.java 2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Type.java 2010-09-09 19:54:58.054019539 +0100
+@@ -1061,6 +1061,21 @@
+ return qtype.isErroneous();
+ }
+
++ /**
++ * Replaces this ForAll's typevars with a set of concrete Java types
++ * and returns the instantiated generic type. Subclasses might override
++ * in order to check that the list of types is a valid instantiation
++ * of the ForAll's typevars.
++ *
++ * @param actuals list of actual types
++ * @param types types instance
++ * @return qtype where all occurrences of tvars are replaced
++ * by types in actuals
++ */
++ public Type inst(List<Type> actuals, Types types) {
++ return types.subst(qtype, tvars, actuals);
++ }
++
+ public Type map(Mapping f) {
+ return f.apply(qtype);
+ }
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Types.java openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Types.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/code/Types.java 2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/code/Types.java 2010-09-09 19:54:58.054019539 +0100
+@@ -331,6 +331,14 @@
+ if (s.tag >= firstPartialTag)
+ return isSuperType(s, t);
+
++ if (s.isCompound()) {
++ for (Type s2 : interfaces(s).prepend(supertype(s))) {
++ if (!isSubtype(t, s2, capture))
++ return false;
++ }
++ return true;
++ }
++
+ Type lower = lowerBound(s);
+ if (s != lower)
+ return isSubtype(capture ? capture(t) : t, lower, false);
+@@ -2766,6 +2774,14 @@
+ /**
+ * Capture conversion as specified by JLS 3rd Ed.
+ */
++
++ public List<Type> capture(List<Type> ts) {
++ List<Type> buf = List.nil();
++ for (Type t : ts) {
++ buf = buf.prepend(capture(t));
++ }
++ return buf.reverse();
++ }
+ public Type capture(Type t) {
+ if (t.tag != CLASS)
+ return t;
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java 2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Check.java 2010-09-09 19:54:58.054019539 +0100
+@@ -383,6 +383,10 @@
+ JCDiagnostic.fragment("incompatible.types" + (d!=null ? ".1" : ""), d),
+ t, pt);
+ }
++ } catch (Infer.InvalidInstanceException ex) {
++ JCDiagnostic d = ex.getDiagnostic();
++ log.error(pos, "invalid.inferred.types", t.tvars, d);
++ return syms.errType;
+ }
+ }
+ }
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java 2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Infer.java 2010-09-09 20:00:32.891268438 +0100
+@@ -29,6 +29,7 @@
+ import com.sun.tools.javac.util.List;
+ import com.sun.tools.javac.code.*;
+ import com.sun.tools.javac.code.Type.*;
++import com.sun.tools.javac.code.Symbol.*;
+
+ import static com.sun.tools.javac.code.Flags.*;
+ import static com.sun.tools.javac.code.Kinds.*;
+@@ -50,6 +51,7 @@
+
+ Symtab syms;
+ Types types;
++ Resolve rs;
+
+ public static Infer instance(Context context) {
+ Infer instance = context.get(inferKey);
+@@ -62,43 +64,51 @@
+ context.put(inferKey, this);
+ syms = Symtab.instance(context);
+ types = Types.instance(context);
++ rs = Resolve.instance(context);
+ }
+
+- public static class NoInstanceException extends RuntimeException {
++ public static class InferenceException extends RuntimeException {
+ private static final long serialVersionUID = 0;
+
+- boolean isAmbiguous; // exist several incomparable best instances?
+-
+ JCDiagnostic diagnostic;
+
+- NoInstanceException(boolean isAmbiguous) {
++ InferenceException() {
+ this.diagnostic = null;
+- this.isAmbiguous = isAmbiguous;
+- }
+- NoInstanceException setMessage(String key) {
+- this.diagnostic = JCDiagnostic.fragment(key);
+- return this;
+- }
+- NoInstanceException setMessage(String key, Object arg1) {
+- this.diagnostic = JCDiagnostic.fragment(key, arg1);
+- return this;
+- }
+- NoInstanceException setMessage(String key, Object arg1, Object arg2) {
+- this.diagnostic = JCDiagnostic.fragment(key, arg1, arg2);
+- return this;
+ }
+- NoInstanceException setMessage(String key, Object arg1, Object arg2, Object arg3) {
+- this.diagnostic = JCDiagnostic.fragment(key, arg1, arg2, arg3);
++ InferenceException setMessage(String key, Object... args) {
++ this.diagnostic = JCDiagnostic.fragment(key, args);
+ return this;
+ }
++
+ public JCDiagnostic getDiagnostic() {
+ return diagnostic;
+ }
+ }
++
++ public static class NoInstanceException extends InferenceException {
++ private static final long serialVersionUID = 1;
++
++ boolean isAmbiguous; // exist several incomparable best instances?
++
++ NoInstanceException(boolean isAmbiguous) {
++ super();
++ this.isAmbiguous = isAmbiguous;
++ }
++ }
++
++ public static class InvalidInstanceException extends InferenceException {
++ private static final long serialVersionUID = 2;
++
++ InvalidInstanceException() {
++ super();
++ }
++ }
++
+ private final NoInstanceException ambiguousNoInstanceException =
+ new NoInstanceException(true);
+ private final NoInstanceException unambiguousNoInstanceException =
+ new NoInstanceException(false);
++ private final InvalidInstanceException invalidInstanceException = new InvalidInstanceException();
+
+ /***************************************************************************
+ * Auxiliary type values and classes
+@@ -247,7 +257,7 @@
+ */
+ public Type instantiateExpr(ForAll that,
+ Type to,
+- Warner warn) throws NoInstanceException {
++ Warner warn) throws InferenceException {
+ List<Type> undetvars = Type.map(that.tvars, fromTypeVarFun);
+ for (List<Type> l = undetvars; l.nonEmpty(); l = l.tail) {
+ UndetVar v = (UndetVar) l.head;
+@@ -273,8 +283,7 @@
+ List<Type> targs = Type.map(undetvars, getInstFun);
+ targs = types.subst(targs, that.tvars, targs);
+ checkWithinBounds(that.tvars, targs, warn);
+-
+- return getInstFun.apply(qtype1);
++ return that.inst(targs, types);
+ }
+
+ /** Instantiate method type `mt' by finding instantiations of
+@@ -282,36 +291,42 @@
+ */
+ public Type instantiateMethod(List<Type> tvars,
+ MethodType mt,
+- List<Type> argtypes,
+- boolean allowBoxing,
+- boolean useVarargs,
+- Warner warn) throws NoInstanceException {
++ final List<Type> argtypes,
++ final boolean allowBoxing,
++ final boolean useVarargs,
++ final Warner warn) throws InferenceException {
+ //-System.err.println("instantiateMethod(" + tvars + ", " + mt + ", " + argtypes + ")"); //DEBUG
+ List<Type> undetvars = Type.map(tvars, fromTypeVarFun);
+ List<Type> formals = mt.argtypes;
+-
++ //need to capture exactly once - otherwise subsequent
++ //applicability checks might fail
++ final List<Type> capturedArgs = types.capture(argtypes);
++ List<Type> actuals = capturedArgs;
++ List<Type> actualsNoCapture = argtypes;
+ // instantiate all polymorphic argument types and
+ // set up lower bounds constraints for undetvars
+ Type varargsFormal = useVarargs ? formals.last() : null;
+- while (argtypes.nonEmpty() && formals.head != varargsFormal) {
+- Type ft = formals.head;
+- Type at = argtypes.head.baseType();
+- if (at.tag == FORALL)
+- at = instantiateArg((ForAll) at, ft, tvars, warn);
+- Type sft = types.subst(ft, tvars, undetvars);
++ while (actuals.nonEmpty() && formals.head != varargsFormal) {
++ Type formal = formals.head;
++ Type actual = actuals.head.baseType();
++ Type actualNoCapture = actualsNoCapture.head.baseType();
++ if (actual.tag == FORALL)
++ actual = instantiateArg((ForAll)actual, formal, tvars, warn);
++ Type undetFormal = types.subst(formal, tvars, undetvars);
+ boolean works = allowBoxing
+- ? types.isConvertible(at, sft, warn)
+- : types.isSubtypeUnchecked(at, sft, warn);
++ ? types.isConvertible(actual, undetFormal, warn)
++ : types.isSubtypeUnchecked(actual, undetFormal, warn);
+ if (!works) {
+ throw unambiguousNoInstanceException
+ .setMessage("no.conforming.assignment.exists",
+- tvars, at, ft);
++ tvars, actualNoCapture, formal);
+ }
+ formals = formals.tail;
+- argtypes = argtypes.tail;
++ actuals = actuals.tail;
++ actualsNoCapture = actualsNoCapture.tail;
+ }
+ if (formals.head != varargsFormal || // not enough args
+- !useVarargs && argtypes.nonEmpty()) { // too many args
++ !useVarargs && actuals.nonEmpty()) { // too many args
+ // argument lists differ in length
+ throw unambiguousNoInstanceException
+ .setMessage("arg.length.mismatch");
+@@ -319,20 +334,21 @@
+
+ // for varargs arguments as well
+ if (useVarargs) {
+- Type elt = types.elemtype(varargsFormal);
+- Type sft = types.subst(elt, tvars, undetvars);
+- while (argtypes.nonEmpty()) {
+- Type ft = sft;
+- Type at = argtypes.head.baseType();
+- if (at.tag == FORALL)
+- at = instantiateArg((ForAll) at, ft, tvars, warn);
+- boolean works = types.isConvertible(at, sft, warn);
++ Type elemType = types.elemtype(varargsFormal);
++ Type elemUndet = types.subst(elemType, tvars, undetvars);
++ while (actuals.nonEmpty()) {
++ Type actual = actuals.head.baseType();
++ Type actualNoCapture = actualsNoCapture.head.baseType();
++ if (actual.tag == FORALL)
++ actual = instantiateArg((ForAll)actual, elemType, tvars, warn);
++ boolean works = types.isConvertible(actual, elemUndet, warn);
+ if (!works) {
+ throw unambiguousNoInstanceException
+ .setMessage("no.conforming.assignment.exists",
+- tvars, at, ft);
++ tvars, actualNoCapture, elemType);
+ }
+- argtypes = argtypes.tail;
++ actuals = actuals.tail;
++ actualsNoCapture = actualsNoCapture.tail;
+ }
+ }
+
+@@ -363,16 +379,38 @@
+ }
+ checkWithinBounds(tvars, undettypes.toList(), warn);
+
++ mt = (MethodType)types.subst(mt, tvars, insttypes.toList());
++
+ if (!restvars.isEmpty()) {
+ // if there are uninstantiated variables,
+ // quantify result type with them
+- mt = new MethodType(mt.argtypes,
+- new ForAll(restvars.toList(), mt.restype),
+- mt.thrown, syms.methodClass);
++ final List<Type> inferredTypes = insttypes.toList();
++ final List<Type> all_tvars = tvars; //this is the wrong tvars
++ final MethodType mt2 = new MethodType(mt.argtypes, null, mt.thrown, syms.methodClass);
++ mt2.restype = new ForAll(restvars.toList(), mt.restype) {
++ @Override
++ public Type inst(List<Type> inferred, Types types) throws NoInstanceException {
++ List<Type> formals = types.subst(mt2.argtypes, tvars, inferred);
++ if (!rs.argumentsAcceptable(capturedArgs, formals,
++ allowBoxing, useVarargs, warn)) {
++ // inferred method is not applicable
++ throw invalidInstanceException.setMessage("inferred.do.not.conform.to.params", formals, argtypes);
++ }
++ // check that inferred bounds conform to their bounds
++ checkWithinBounds(all_tvars,
++ types.subst(inferredTypes, tvars, inferred), warn);
++ return super.inst(inferred, types);
++ }};
++ return mt2;
++ }
++ else if (!rs.argumentsAcceptable(capturedArgs, mt.getParameterTypes(), allowBoxing, useVarargs, warn)) {
++ // inferred method is not applicable
++ throw invalidInstanceException.setMessage("inferred.do.not.conform.to.params", mt.getParameterTypes(), argtypes);
++ }
++ else {
++ // return instantiated version of method type
++ return mt;
+ }
+-
+- // return instantiated version of method type
+- return types.subst(mt, tvars, insttypes.toList());
+ }
+ //where
+
+@@ -384,7 +422,7 @@
+ private Type instantiateArg(ForAll that,
+ Type to,
+ List<Type> tvars,
+- Warner warn) throws NoInstanceException {
++ Warner warn) throws InferenceException {
+ List<Type> targs;
+ try {
+ return instantiateExpr(that, to, warn);
+@@ -401,16 +439,16 @@
+ private void checkWithinBounds(List<Type> tvars,
+ List<Type> arguments,
+ Warner warn)
+- throws NoInstanceException {
++ throws InvalidInstanceException {
+ for (List<Type> tvs = tvars, args = arguments;
+ tvs.nonEmpty();
+ tvs = tvs.tail, args = args.tail) {
+ if (args.head instanceof UndetVar) continue;
+ List<Type> bounds = types.subst(types.getBounds((TypeVar)tvs.head), tvars, arguments);
+ if (!types.isSubtypeUnchecked(args.head, bounds, warn))
+- throw unambiguousNoInstanceException
++ throw invalidInstanceException
+ .setMessage("inferred.do.not.conform.to.bounds",
+- arguments, tvars);
++ args.head, bounds);
+ }
+ }
+ }
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java 2010-06-21 22:16:20.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/comp/Resolve.java 2010-09-09 19:54:58.058019555 +0100
+@@ -279,7 +279,7 @@
+ boolean allowBoxing,
+ boolean useVarargs,
+ Warner warn)
+- throws Infer.NoInstanceException {
++ throws Infer.InferenceException {
+ if (useVarargs && (m.flags() & VARARGS) == 0) return null;
+ Type mt = types.memberType(site, m);
+
+@@ -350,7 +350,7 @@
+ try {
+ return rawInstantiate(env, site, m, argtypes, typeargtypes,
+ allowBoxing, useVarargs, warn);
+- } catch (Infer.NoInstanceException ex) {
++ } catch (Infer.InferenceException ex) {
+ return null;
+ }
+ }
+@@ -562,7 +562,7 @@
+ default: return bestSoFar;
+ }
+ }
+- } catch (Infer.NoInstanceException ex) {
++ } catch (Infer.InferenceException ex) {
+ switch (bestSoFar.kind) {
+ case ABSENT_MTH:
+ return wrongMethod.setWrongSym(sym, ex.getDiagnostic());
+diff -Nru openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties openjdk/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties
+--- openjdk.orig/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties 2010-06-21 22:16:21.000000000 +0100
++++ openjdk/langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties 2010-09-09 19:54:58.058019555 +0100
+@@ -454,6 +454,8 @@
+ type parameters of {0} cannot be determined
+ compiler.err.undetermined.type.1=\
+ type parameters of {0} cannot be determined; {1}
++compiler.err.invalid.inferred.types=\
++ invalid inferred types for {0}; {1}
+ compiler.err.unreachable.stmt=\
+ unreachable statement
+ compiler.err.initializer.must.be.able.to.complete.normally=\
+@@ -960,7 +962,13 @@
+ compiler.misc.arg.length.mismatch=\
+ cannot instantiate from arguments because actual and formal argument lists differ in length
+ compiler.misc.inferred.do.not.conform.to.bounds=\
+- inferred type argument(s) {0} do not conform to bounds of type variable(s) {1}
++ inferred type does not conform to declared bound(s)\n\
++ inferred: {0}\n\
++ bound(s): {1}
++compiler.misc.inferred.do.not.conform.to.params=\
++ actual arguments do not conforms to inferred formal arguments\n\
++ required: {0}\n\
++ found: {1}
+
+ #####
+
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6302954/T6476073.java openjdk/langtools/test/tools/javac/generics/inference/6302954/T6476073.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6302954/T6476073.java 2010-06-21 22:16:25.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6302954/T6476073.java 2010-09-09 19:54:58.058019555 +0100
+@@ -25,6 +25,7 @@
+ * @test
+ * @bug 6476073
+ * @summary Capture using super wildcard of type variables doesn't work
++ * @ignore awaiting for 6650759 (see bug report for a detailed evaluation)
+ * @compile T6476073.java
+ */
+
+diff -Nru openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712a.java openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712a.java
+--- openjdk.orig/langtools/test/tools/javac/generics/inference/6638712/T6638712a.java 1970-01-01 01:00:00.000000000 +0100
++++ openjdk/langtools/test/tools/javac/generics/inference/6638712/T6638712a.java 2010-09-09 19:54:58.062019572 +0100
+@@ -0,0 +1,41 @@
++/*
++ * Copyright 2009 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
++ * CA 95054 USA or visit www.sun.com if you need additional information or
++ * have any questions.
++ */
++
++/*
++ * @test
++ * @bug 6638712
++ * @author mcimadamore
----- End forwarded message -----
--
Andrew :)
Free Java Software Engineer
Red Hat, Inc. (http://www.redhat.com)
Support Free Java!
Contribute to GNU Classpath and the OpenJDK
http://www.gnu.org/software/classpath
http://openjdk.java.net
PGP Key: 94EFD9D8 (http://subkeys.pgp.net)
Fingerprint = F8EF F1EA 401E 2E60 15FA 7927 142C 2591 94EF D9D8
More information about the distro-pkg-dev
mailing list