Coverage rate of diff is 88
changeset: 50453:f91927a2c8d3
user: jjg
date: Thu Jun 07 16:06:49 2018 -0700
summary: 8201274: Launch Single-File Source-Code Programs

  com/sun/tools/javac/launcher/Main.java: Main.void main(java.lang.String[])
+ 119 | new Main(System.err).run(VM.getRuntimeArguments(), args);
+ 120 | } catch (Fault f) {
+ 121 | System.err.println(f.getMessage());
+ 122 | System.exit(1);
- 123 | } catch (InvocationTargetException e) {
    124 | // leave VM to handle the stacktrace, in the standard manner
- 125 | throw e.getTargetException();
+ 126 | }
+ 127 | }
  com/sun/tools/javac/launcher/Main.java: Main.void <init>(java.io.PrintStream)
+ 139 | this(new PrintWriter(new OutputStreamWriter(out), true));
+ 140 | }
  com/sun/tools/javac/launcher/Main.java: Main.void <init>(java.io.PrintWriter)
+ 148 | public Main(PrintWriter out) {
+ 149 | this.out = out;
+ 150 | }
    151 |
    152 | /**
    153 | * Compiles a source file, and executes the main method it contains.
    154 | *
    155 | * <p>The first entry in the {@code args} array is the source file
    156 | * to be compiled and run; all subsequent entries are passed as
    157 | * arguments to the main method of the first class found in the file.
    158 | *
    159 | * <p>Options for {@code javac} are obtained by filtering the runtime arguments.
    160 | *
    161 | * <p>If the main method throws an exception, it will be propagated in an
    162 | * {@code InvocationTargetException}. In that case, the stack trace of the
    163 | * target exception will be truncated such that the main method will be the
    164 | * last entry on the stack. In other words, the stack frames leading up to the
    165 | * invocation of the main method will be removed.
    166 | *
    167 | * @param runtimeArgs the runtime arguments
    168 | * @param args the arguments
    169 | * @throws Fault if a problem is detected before the main method can be executed
    170 | * @throws InvocationTargetException if the main method throws an exception
    171 | */
    172 | public void run(String[] runtimeArgs, String[] args) throws Fault, InvocationTargetException {
+ 173 | Path file = getFile(args);
    174 |
+ 175 | Context context = new Context();
+ 176 | String mainClassName = compile(file, getJavacOpts(runtimeArgs), context);
    177 |
+ 178 | String[] appArgs = Arrays.copyOfRange(args, 1, args.length);
+ 179 | execute(mainClassName, appArgs, context);
+ 180 | }
    181 |
    182 | /**
    183 | * Returns the path for the filename found in the first of an array of arguments.
    184 | *
    185 | * @param args the array
    186 | * @return the path
    187 | * @throws Fault if there is a problem determining the path, or if the file does not exist
    188 | */
    189 | private Path getFile(String[] args) throws Fault {
+ 190 | if (args.length == 0) {
    191 | // should not happen when invoked from launcher
- 192 | throw new Fault(Errors.NoArgs);
    193 | }
    194 | Path file;
    195 | try {
+ 196 | file = Paths.get(args[0]);
- 197 | } catch (InvalidPathException e) {
- 198 | throw new Fault(Errors.InvalidFilename(args[0]));
+ 199 | }
+ 200 | if (!Files.exists(file)) {
    201 | // should not happen when invoked from launcher
- 202 | throw new Fault(Errors.FileNotFound(file));
    203 | }
+ 204 | return file;
    205 | }
    206 |
    207 | /**
    208 | * Reads a source file, ignoring the first line if it is not a Java source file and
    209 | * it begins with {@code #!}.
    210 | *
    211 | * <p>If it is not a Java source file, and if the first two bytes are {@code #!},
    212 | * indicating a "magic number" of an executable text file, the rest of the first line
    213 | * up to but not including the newline is ignored. All characters after the first two are
    214 | * read in the {@link Charset#defaultCharset default platform encoding}.
    215 | *
    216 | * @param file the file
    217 | * @return a file object containing the content of the file
    218 | * @throws Fault if an error occurs while reading the file
    219 | */
    220 | private JavaFileObject readFile(Path file) throws Fault {
    221 | // use a BufferedInputStream to guarantee that we can use mark and reset.
+ 222 | try (BufferedInputStream in = new BufferedInputStream(Files.newInputStream(file))) {
    223 | boolean ignoreFirstLine;
+ 224 | if (file.getFileName().toString().endsWith(".java")) {
+ 225 | ignoreFirstLine = false;
    226 | } else {
+ 227 | in.mark(2);
+ 228 | ignoreFirstLine = (in.read() == '#') && (in.read() == '!');
+ 229 | if (!ignoreFirstLine) {
- 230 | in.reset();
    231 | }
    232 | }
+ 233 | try (BufferedReader r = new BufferedReader(new InputStreamReader(in, Charset.defaultCharset()))) {
+ 234 | StringBuilder sb = new StringBuilder();
+ 235 | if (ignoreFirstLine) {
+ 236 | r.readLine();
+ 237 | sb.append("\n"); // preserve line numbers
    238 | }
+ 239 | char[] buf = new char[1024];
    240 | int n;
+ 241 | while ((n = r.read(buf, 0, buf.length)) != -1) {
+ 242 | sb.append(buf, 0, n);
    243 | }
+ 244 | return new SimpleJavaFileObject(file.toUri(), SOURCE) {
    245 | @Override
    246 | public String getName() {
+ 247 | return file.toString();
    248 | }
    249 | @Override
    250 | public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+ 251 | return sb;
    252 | }
    253 | @Override
    254 | public boolean isNameCompatible(String simpleName, JavaFileObject.Kind kind) {
    255 | // reject package-info and module-info; accept other names
+ 256 | return (kind == JavaFileObject.Kind.SOURCE)
+ 257 | && SourceVersion.isIdentifier(simpleName);
    258 | }
    259 | @Override
    260 | public String toString() {
- 261 | return "JavacSourceLauncher[" + file + "]";
    262 | }
    263 | };
+ 264 | }
+ 265 | } catch (IOException e) {
- 266 | throw new Fault(Errors.CantReadFile(file, e));
    267 | }
    268 | }
    269 |
    270 | /**
    271 | * Returns the subset of the runtime arguments that are relevant to {@code javac}.
    272 | * Generally, the relevant options are those for setting paths and for configuring the
    273 | * module system.
    274 | *
    275 | * @param runtimeArgs the runtime arguments
    276 | * @return the subset of the runtime arguments
    277 | **/
    278 | private List<String> getJavacOpts(String... runtimeArgs) throws Fault {
+ 279 | List<String> javacOpts = new ArrayList<>();
    280 |
+ 281 | String sourceOpt = System.getProperty("jdk.internal.javac.source");
+ 282 | if (sourceOpt != null) {
+ 283 | Source source = Source.lookup(sourceOpt);
+ 284 | if (source == null) {
+ 285 | throw new Fault(Errors.InvalidValueForSource(sourceOpt));
    286 | }
+ 287 | javacOpts.addAll(List.of("--release", sourceOpt));
    288 | }
    289 |
+ 290 | for (int i = 0; i < runtimeArgs.length; i++) {
+ 291 | String arg = runtimeArgs[i];
+ 292 | String opt = arg, value = null;
+ 293 | if (arg.startsWith("--")) {
+ 294 | int eq = arg.indexOf('=');
+ 295 | if (eq > 0) {
+ 296 | opt = arg.substring(0, eq);
+ 297 | value = arg.substring(eq + 1);
    298 | }
    299 | }
+ 300 | switch (opt) {
    301 | // The following options all expect a value, either in the following
    302 | // position, or after '=', for options beginning "--".
    303 | case "--class-path": case "-classpath": case "-cp":
    304 | case "--module-path": case "-p":
    305 | case "--add-exports":
    306 | case "--add-modules":
    307 | case "--limit-modules":
    308 | case "--patch-module":
    309 | case "--upgrade-module-path":
+ 310 | if (value == null) {
+ 311 | if (i== runtimeArgs.length - 1) {
    312 | // should not happen when invoked from launcher
- 313 | throw new Fault(Errors.NoValueForOption(opt));
    314 | }
+ 315 | value = runtimeArgs[++i];
    316 | }
+ 317 | if (opt.equals("--add-modules") && value.equals("ALL-DEFAULT")) {
    318 | // this option is only supported at run time;
    319 | // it is not required or supported at compile time
+ 320 | break;
    321 | }
+ 322 | javacOpts.add(opt);
+ 323 | javacOpts.add(value);
+ 324 | break;
    325 | case "--enable-preview":
+ 326 | javacOpts.add(opt);
+ 327 | if (sourceOpt == null) {
+ 328 | throw new Fault(Errors.EnablePreviewRequiresSource);
    329 | }
    330 | break;
    331 | default:
    332 | // ignore all other runtime args
    333 | }
    334 | }
    335 |
    336 | // add implicit options
+ 337 | javacOpts.add("-proc:none");
    338 |
+ 339 | return javacOpts;
    340 | }
    341 |
    342 | /**
    343 | * Compiles a source file, placing the class files in a map in memory.
    344 | * Any messages generated during compilation will be written to the stream
    345 | * provided when this object was created.
    346 | *
    347 | * @param file the source file
    348 | * @param javacOpts compilation options for {@code javac}
    349 | * @param context the context for the compilation
    350 | * @return the name of the first class found in the source file
    351 | * @throws Fault if any compilation errors occur, or if no class was found
    352 | */
    353 | private String compile(Path file, List<String> javacOpts, Context context) throws Fault {
+ 354 | JavaFileObject fo = readFile(file);
    355 |
+ 356 | JavacTool javaCompiler = JavacTool.create();
+ 357 | StandardJavaFileManager stdFileMgr = javaCompiler.getStandardFileManager(null, null, null);
    358 | try {
+ 359 | stdFileMgr.setLocation(StandardLocation.SOURCE_PATH, Collections.emptyList());
- 360 | } catch (IOException e) {
- 361 | throw new java.lang.Error("unexpected exception from file manager", e);
+ 362 | }
+ 363 | JavaFileManager fm = context.getFileManager(stdFileMgr);
+ 364 | JavacTask t = javaCompiler.getTask(out, fm, null, javacOpts, null, List.of(fo));
+ 365 | MainClassListener l = new MainClassListener(t);
+ 366 | Boolean ok = t.call();
+ 367 | if (!ok) {
+ 368 | throw new Fault(Errors.CompilationFailed);
    369 | }
+ 370 | if (l.mainClass == null) {
+ 371 | throw new Fault(Errors.NoClass);
    372 | }
+ 373 | String mainClassName = l.mainClass.getQualifiedName().toString();
+ 374 | return mainClassName;
    375 | }
    376 |
    377 | /**
    378 | * Invokes the {@code main} method of a specified class, using a class loader that
    379 | * will load recently compiled classes from memory.
    380 | *
    381 | * @param mainClassName the class to be executed
    382 | * @param appArgs the arguments for the {@code main} method
    383 | * @param context the context for the class to be executed
    384 | * @throws Fault if there is a problem finding or invoking the {@code main} method
    385 | * @throws InvocationTargetException if the {@code main} method throws an exception
    386 | */
    387 | private void execute(String mainClassName, String[] appArgs, Context context)
    388 | throws Fault, InvocationTargetException {
+ 389 | ClassLoader cl = context.getClassLoader(ClassLoader.getSystemClassLoader());
    390 | try {
+ 391 | Class<?> appClass = Class.forName(mainClassName, true, cl);
+ 392 | if (appClass.getClassLoader() != cl) {
+ 393 | throw new Fault(Errors.UnexpectedClass(mainClassName));
    394 | }
+ 395 | Method main = appClass.getDeclaredMethod("main", String[].class);
+ 396 | int PUBLIC_STATIC = Modifier.PUBLIC | Modifier.STATIC;
+ 397 | if ((main.getModifiers() & PUBLIC_STATIC) != PUBLIC_STATIC) {
+ 398 | throw new Fault(Errors.MainNotPublicStatic);
    399 | }
+ 400 | if (!main.getReturnType().equals(void.class)) {
+ 401 | throw new Fault(Errors.MainNotVoid);
    402 | }
+ 403 | main.setAccessible(true);
+ 404 | main.invoke(0, (Object) appArgs);
- 405 | } catch (ClassNotFoundException e) {
- 406 | throw new Fault(Errors.CantFindClass(mainClassName));
+ 407 | } catch (NoSuchMethodException e) {
+ 408 | throw new Fault(Errors.CantFindMainMethod(mainClassName));
- 409 | } catch (IllegalAccessException e) {
- 410 | throw new Fault(Errors.CantAccessMainMethod(mainClassName));
+ 411 | } catch (InvocationTargetException e) {
    412 | // remove stack frames for source launcher
+ 413 | int invocationFrames = e.getStackTrace().length;
+ 414 | Throwable target = e.getTargetException();
+ 415 | StackTraceElement[] targetTrace = target.getStackTrace();
+ 416 | target.setStackTrace(Arrays.copyOfRange(targetTrace, 0, targetTrace.length - invocationFrames));
+ 417 | throw e;
+ 418 | }
+ 419 | }
    420 |
    421 | private static final String bundleName = "com.sun.tools.javac.resources.launcher";
+ 422 | private ResourceBundle resourceBundle = null;
  com/sun/tools/javac/launcher/Main.java: Main.java.lang.String getMessage(com.sun.tools.javac.util.JCDiagnostic$Error)
+ 432 | String key = error.key();
+ 433 | Object[] args = error.getArgs();
    434 | try {
+ 435 | if (resourceBundle == null) {
+ 436 | resourceBundle = ResourceBundle.getBundle(bundleName);
+ 437 | errorPrefix = resourceBundle.getString("launcher.error");
    438 | }
+ 439 | String resource = resourceBundle.getString(key);
+ 440 | String message = MessageFormat.format(resource, args);
+ 441 | return errorPrefix + message;
- 442 | } catch (MissingResourceException e) {
- 443 | return "Cannot access resource; " + key + Arrays.toString(args);
  com/sun/tools/javac/launcher/Main.java: Main.java.lang.String access$000(com.sun.tools.javac.launcher.Main,com.sun.tools.javac.util.JCDiagnostic$Error)
+ 88 |public class Main {
  com/sun/tools/javac/launcher/Main.java: Main.void <init>()
+ 473 | private static class Context {
+ 474 | private Map<String, byte[]> inMemoryClasses = new HashMap<>();
  com/sun/tools/javac/launcher/Main.java: Main.javax.tools.JavaFileManager getFileManager(javax.tools.StandardJavaFileManager)
+ 477 | return new MemoryFileManager(inMemoryClasses, delegate);
  com/sun/tools/javac/launcher/Main.java: Main.java.lang.ClassLoader getClassLoader(java.lang.ClassLoader)
+ 481 | return new MemoryClassLoader(inMemoryClasses, parent);
  com/sun/tools/javac/launcher/Main.java: Main.void <init>(com.sun.tools.javac.launcher.Main,com.sun.tools.javac.util.JCDiagnostic$Error)
+ 94 | Fault(Error error) {
+ 95 | super(Main.this.getMessage(error));
+ 96 | }
  com/sun/tools/javac/launcher/Main.java: Main.void <init>(com.sun.source.util.JavacTask)
+ 453 | MainClassListener(JavacTask t) {
+ 454 | t.addTaskListener(this);
+ 455 | }
  com/sun/tools/javac/launcher/Main.java: Main.void started(com.sun.source.util.TaskEvent)
+ 459 | if (ev.getKind() == TaskEvent.Kind.ANALYZE && mainClass == null) {
+ 460 | TypeElement te = ev.getTypeElement();
+ 461 | if (te.getNestingKind() == NestingKind.TOP_LEVEL) {
+ 462 | mainClass = te;
    463 | }
    464 | }
+ 465 | }
  com/sun/tools/javac/launcher/Main.java: Main.void <init>(java.util.Map,java.lang.ClassLoader)
+ 537 | super(parent);
+ 538 | this.map = map;
+ 539 | }
  com/sun/tools/javac/launcher/Main.java: Main.java.lang.Class findClass(java.lang.String)
+ 543 | byte[] bytes = map.get(name);
+ 544 | if (bytes == null) {
- 545 | throw new ClassNotFoundException(name);
    546 | }
+ 547 | return defineClass(name, bytes, 0, bytes.length);
  com/sun/tools/javac/launcher/Main.java: Main.void <init>(java.util.Map,javax.tools.JavaFileManager)
+ 496 | super(delegate);
+ 497 | this.map = map;
+ 498 | }
  com/sun/tools/javac/launcher/Main.java: Main.javax.tools.JavaFileObject getJavaFileForOutput(javax.tools.JavaFileManager$Location,java.lang.String,javax.tools.JavaFileObject$Kind,javax.tools.FileObject)
+ 503 | if (location == StandardLocation.CLASS_OUTPUT && kind == JavaFileObject.Kind.CLASS) {
+ 504 | return createInMemoryClassFile(className);
    505 | } else {
- 506 | return super.getJavaFileForOutput(location, className, kind, sibling);
  com/sun/tools/javac/launcher/Main.java: Main.javax.tools.JavaFileObject createInMemoryClassFile(java.lang.String)
+ 511 | URI uri = URI.create("memory:///" + className.replace('.', '/') + ".class");
+ 512 | return new SimpleJavaFileObject(uri, JavaFileObject.Kind.CLASS) {
  com/sun/tools/javac/launcher/Main.java: Main.java.util.Map access$200(com.sun.tools.javac.launcher.Main$MemoryFileManager)
+ 492 | private static class MemoryFileManager extends ForwardingJavaFileManager<JavaFileManager> {
  com/sun/tools/javac/launcher/Main.java: Main.java.io.OutputStream openOutputStream()
+ 515 | return new ByteArrayOutputStream() {
  com/sun/tools/javac/launcher/Main.java: Main.void close()
+ 518 | super.close();
+ 519 | map.put(className, toByteArray());
+ 520 | }
  sun/launcher/LauncherHelper.java: LauncherHelper.java.lang.Class checkAndLoadMain(boolean,int,java.lang.String)
+ 548 | Class<?> mainClass = null;
+ 549 | switch (mode) {
    550 | case LM_MODULE: case LM_SOURCE:
+ 551 | mainClass = loadModuleMainClass(what);
+ 552 | break;
    553 | default:
+ 554 | mainClass = loadMainClass(mode, what);
    555 | break;
    556 | }
  sun/launcher/LauncherHelper.java: LauncherHelper.void <clinit>()
    505 | // enum LaunchMode { LM_UNKNOWN = 0, LM_CLASS, LM_JAR, LM_MODULE, LM_SOURCE }
    511 | private static final int LM_SOURCE = 4;
    542 | @SuppressWarnings("fallthrough")
lines: 563 new; 157 covered; 20 not covered; 386 not code; 0 no information