Which means the InputStreamReader is never closed

Eh? In your code it is... And it will certainly handle the .close() of your resource stream as well. See below for more details...

As @SotiriosDelimanolis mentions however you can declare more than one resource in the "resource block" of a try-with-resources statement.

You have another problem here: .getResourceAsStream() can return null; you may therefore have an NPE.

I'd do this if I were you:

final URL url = ModelCodeGenerator.class.getClassLoader()
    .getResource("/model.java.txt");

if (url == null)
    throw new IOException("resource not found");

try (
    final InputStream in = url.openStream();
    final Reader reader = new InputStreamReader(in, someCharsetOrDecoder);
) {
    // manipulate resources
}

There is a very important point to consider however...

Closeable does extend AutoCloseable, yes; in fact it only differs, "signature wise", by the exception thrown (IOException vs Exception). But there is a fundamental difference in behavior.

From the javadoc of AutoCloseable's .close() (emphasis mine):

Note that unlike the close method of Closeable, this close method is not required to be idempotent. In other words, calling this close method more than once may have some visible side effect, unlike Closeable.close which is required to have no effect if called more than once. However, implementers of this interface are strongly encouraged to make their close methods idempotent.

And indeed, the javadoc of Closeable is clear about this:

Closes this stream and releases any system resources associated with it. If the stream is already closed then invoking this method has no effect.

You have two very important points:

• by contract, a Closeable also takes care of all resources associated with it; so, if you close a BufferedReader which wraps a Reader which wraps an InputStream, all three are closed;
• should you call .close() more than once, there is no further side effect.

This also means, of course, that you can choose the paranoid option and keep a reference to all Closeable resources and close them all; beware however if you have AutoCloseable resources into the mix which are not Closeable!

It's safe, but it will be closed, so I don't think it is particularly useful... (You can't reopen a closed stream.)

See this example:

public static void main(String[] argv) throws Exception {
    System.out.println(example());
}

public static InputStream example() throws IOException {
    try (InputStream is = Files.newInputStream(Paths.get("test.txt"))) {
        System.out.println(is);
        return is;
    }
}

Output:

sun.nio.ch.ChannelInputStream@1db9742
sun.nio.ch.ChannelInputStream@1db9742

The (same) input stream is returned (same by reference), but it will be closed. By modifying the example to this:

public static void main(String[] argv) throws Exception {
    InputStream is = example();
    System.out.println(is + " " + is.available());
}

public static InputStream example() throws IOException {
    try (InputStream is = Files.newInputStream(Paths.get("test.txt"))) {
        System.out.println(is + " " + is.available());
        return is;
    }
}

Output:

sun.nio.ch.ChannelInputStream@1db9742 1000000
Exception in thread "main" java.nio.channels.ClosedChannelException
    at sun.nio.ch.FileChannelImpl.ensureOpen(FileChannelImpl.java:109)
    at sun.nio.ch.FileChannelImpl.size(FileChannelImpl.java:299)
    at sun.nio.ch.ChannelInputStream.available(ChannelInputStream.java:116)
    at sandbox.app.Main.main(Main.java:13)

Yes, that is the common pre-Java 7 solution. However, with the introduction of Java 7, there are now try-with-resource statements which will automatically close any declared resources when the try block exits:

try (FileInputStream fileIn = ...) {
    // do something
} // fileIn is closed
catch (IOException e) {
    //handle exception
}

It seems to work

It will do if you add InputStream (or some supertype of InputStream) before in: the language spec requires you either to declare a variable for each resource.

try (InputStream in = fileIn) { ... }

or just refer directly to fileIn, in Java 9+:

try (fileIn) { ... }

And there's no reason why it shouldn't work: with the variable declaration form, you are assigning an expression to the variable (a new class, the result of a method invocation, an array element etc). The resource can't see if it is getting a "new" instance or not: it's just a thing with a value of the correct type.

is it safe?

Depends what exactly you mean by "safe".

It is certainly safe in the sense that it will work without error in this code, and in.close() will be invoked at the end of the block.

However, it violates the rule of thumb that "if you didn't open a stream, don't close it". As such, it might be unsafe in the sense that it causes unexpected failures in other parts of the program that expect the stream still to be open after invoking the method.

Based on Oracle's tutorial, "[the resource] will be closed regardless of whether the try statement completes normally or abruptly". It defines abruptly as from an exception.

Returning inside the try is an example of abrupt completion, as defined by JLS 14.1.