fix(devloop): restart for a new Spring bean or entity the running app never had

flow-devloop-daemon/README.md

@@ -422,6 +422,29 @@ its answer rather than claiming success.
   old one. This includes Spring Data repositories, which are bare interfaces with
   no annotation to spot them by, so the connector keys on the loaded proxy
   instead.
+- **A bean or an entity the application has never seen must restart too.**
+  Component scanning runs once, at startup, over the classes that existed then,
+  and HA's Spring plugins that would rescan are disabled (below) — so a class
+  that is only now being given `@Component`, `@Service`, `@Repository`,
+  `@Controller`, `@RestController`, `@ControllerAdvice`,
+  `@RestControllerAdvice` or `@Configuration` gets no bean definition, and the
+  first injection point fails with `NoSuchBeanDefinitionException` naming
+  Spring rather than the loop. A brand-new `@Entity` is in exactly the same
+  position against a metamodel and a schema fixed at startup. It is the one
+  escalation with no redefine behind it: the class was never loaded, so there
+  is nothing to swap and every signal read off a loaded class is empty. It
+  takes both sides to say so, and deliberately: `REDEFINE` answers which of
+  the change-set's classes carry a stereotype (`stereotypes=`, read out of the
+  compiled bytes — the same reading `@Entity` already needed), and the
+  daemon's own inventory answers which of them the running application never
+  had. **Asking the app whether it has loaded the class does not work**:
+  HotswapAgent watches the output directory on its own schedule and defines a
+  new class when it sees one, so that answer flips between applies — and a
+  defined class is still not a bean definition. The inventory is re-seeded
+  from disk at every registration, so it does not flip. A stereotype composed
+  through a project's own meta-annotation is the known gap: only the custom
+  annotation is in the class's constant pool, so that one is still a restart
+  to ask for by hand.
 - **Hot-swap coverage differs sharply between stock HotSpot and a JBR.** Only a
   JBR gets `-XX:+AllowEnhancedClassRedefinition`; on stock HotSpot a structural
   change is simply rejected and escalates. A project needing a Java version no

flow-devloop-daemon/src/main/java/com/vaadin/flow/devloop/daemon/Compile.java

@@ -200,6 +200,17 @@ private static List<Path> joined(List<Path> first, List<Path> second) {
     private static final List<String> PUBLIC_RESOURCE_ROOTS = List
             .of("META-INF/resources/", "static/", "public/", "resources/");
 
+    /**
+     * What makes a file a Java source, and what a type's name is its file name
+     * minus.
+     */
+    private static final String JAVA_SUFFIX = ".java";
+
+    /**
+     * What makes a file a class file, and what a binary name is its path minus.
+     */
+    private static final String CLASS_SUFFIX = ".class";
+
     /** A file and the module it belongs to, which is all a walk ever needs. */
     private interface Visitor {
         void accept(Reactor.Module module, Path file, Stamp stamp);
@@ -208,6 +219,21 @@ private interface Visitor {
     /** Fingerprints of Java sources as of the last time they went live. */
     private final Map<Path, Stamp> applied = new java.util.concurrent.ConcurrentHashMap<>();
 
+    /**
+     * The binary names of the class files the running application was launched
+     * with, as of the last seed.
+     * <p>
+     * This is the whole of the answer to "has the application ever had this
+     * class?", and it has to be a snapshot rather than anything computed later.
+     * A timestamp cannot serve: the class file of a bean the application does
+     * run is rewritten by the first apply that hot swaps it, and every apply
+     * after that would then read it as a class the application never had -
+     * measured, the second method-body edit to a @Service restarted for a bean
+     * the context had held all along.
+     */
+    private final Set<String> launchedWith = java.util.concurrent.ConcurrentHashMap
+            .newKeySet();
+
     /**
      * Fingerprints as of the last browser notification, keyed by source path.
      */
@@ -724,7 +750,7 @@ List<Path> removeClassArtifacts(List<Path> sources) throws IOException {
                 removed.add(artifact);
             }
             String nestedPrefix = fileName.toString().substring(0,
-                    fileName.toString().length() - ".class".length()) + "$";
+                    fileName.toString().length() - CLASS_SUFFIX.length()) + "$";
             for (Path nested : nestedClasses(directory, nestedPrefix)) {
                 if (Files.deleteIfExists(nested)) {
                     removed.add(nested);
@@ -747,7 +773,7 @@ private static List<Path> nestedClasses(Path directory, String prefix) {
             return entries.filter(path -> {
                 Path name = path.getFileName();
                 return name != null && name.toString().startsWith(prefix)
-                        && name.toString().endsWith(".class");
+                        && name.toString().endsWith(CLASS_SUFFIX);
             }).toList();
         } catch (IOException e) {
             return List.of();
@@ -787,7 +813,7 @@ List<Path> classpathForced(Launch.Project project) {
                 continue;
             }
             walk(module, module.sourceDir(),
-                    path -> path.toString().endsWith(".java"),
+                    path -> path.toString().endsWith(JAVA_SUFFIX),
                     (owner, file, stamp) -> forced.add(file));
         }
         forced.sort(Comparator.naturalOrder());
@@ -805,6 +831,37 @@ List<String> classpathChangedModules(Launch.Project project) {
         }).map(Reactor.Module::name).toList();
     }
 
+    /**
+     * Which of these classes the running application never had.
+     * <p>
+     * Asked per class rather than per source, which is the only way to get it
+     * right: a second top-level class or a nested one, added to a file the
+     * application has always had, is a class the application has never had. And
+     * answered from the snapshot taken when the application was launched, which
+     * is the only thing that stays true - an apply rewrites the class files it
+     * swaps, so anything read off the classpath afterwards says the
+     * application's own beans are strangers to it.
+     * <p>
+     * A class compiled by an earlier apply is therefore still unknown, and
+     * rightly: the application has had it on the classpath since, but component
+     * scanning ran before it existed and no apply re-runs that. Only the
+     * restart does, and that re-seeds this.
+     *
+     * @param binaryNames
+     *            the classes this apply compiled
+     * @return those of them the application never had, sorted
+     */
+    List<String> classesUnknownToTheApp(List<String> binaryNames) {
+        return binaryNames.stream().filter(name -> !launchedWith.contains(name))
+                .sorted(Comparator.naturalOrder()).toList();
+    }
+
+    private static String binaryNameOf(Reactor.Module module, Path classFile) {
+        String relative = module.classesDir().relativize(classFile).toString();
+        return relative.substring(0, relative.length() - CLASS_SUFFIX.length())
+                .replace(File.separatorChar, '.');
+    }
+
     /** Records that these sources are now live in the running JVM. */
     void markSourcesApplied(List<Path> sources) {
         for (Path source : sources) {
@@ -818,17 +875,33 @@ void markSourcesApplied(List<Path> sources) {
      * there.
      */
     void seedFromDisk() {
-        seedFromDisk(Long.MAX_VALUE);
+        seedFromDisk(Long.MAX_VALUE, Long.MAX_VALUE);
     }
 
     /**
+     * @param startedAtMillis
+     *            when the running application was launched, which bounds which
+     *            sources it can have read
      * @param frontendCutoffMillis
      *            how new a frontend file may be and still count as live; see
      *            {@link #seedFrontend(long)}
      */
-    void seedFromDisk(long frontendCutoffMillis) {
+    void seedFromDisk(long startedAtMillis, long frontendCutoffMillis) {
+        seedClasses();
         applied.clear();
-        forEachSource((module, source, stamp) -> applied.put(source, stamp));
+        forEachSource((module, source, stamp) -> {
+            // Only what the application could have read. A source written
+            // after it was launched is not one it started with, whenever this
+            // baseline happens to be taken - and it can be taken late: the
+            // compile leg is built lazily, and a registration is handled a
+            // moment after the command that waited for it returned. Both are
+            // windows a developer's next keystroke fits into, and a baseline
+            // that walks "whatever is on disk now" claims those edits as the
+            // application's own.
+            if (stamp.modified() <= startedAtMillis) {
+                applied.put(source, stamp);
+            }
+        });
         seedResources();
         // Load-bearing for the frontend leg, not just tidiness: a bundled
         // frontend edit escalates to a restart, the restart re-registers, and
@@ -838,10 +911,27 @@ void seedFromDisk(long frontendCutoffMillis) {
         seedFrontend(frontendCutoffMillis);
     }
 
+    /**
+     * The classpath as the application was launched with it, by binary name.
+     * <p>
+     * One walk per application start, which is where a walk of the output
+     * directories belongs: every other answer about it is a comparison against
+     * this.
+     */
+    private void seedClasses() {
+        launchedWith.clear();
+        for (Reactor.Module module : modules) {
+            walk(module, module.classesDir(),
+                    path -> path.toString().endsWith(CLASS_SUFFIX),
+                    (owner, file, stamp) -> launchedWith
+                            .add(binaryNameOf(owner, file)));
+        }
+    }
+
     private void forEachSource(Visitor action) {
         for (Reactor.Module module : modules) {
             walk(module, module.sourceDir(),
-                    path -> path.toString().endsWith(".java"), action);
+                    path -> path.toString().endsWith(JAVA_SUFFIX), action);
         }
     }
 

flow-devloop-daemon/src/main/java/com/vaadin/flow/devloop/daemon/Launch.java

@@ -317,6 +317,41 @@ Project project(Log progress) {
         }
     }
 
+    /**
+     * The resolved project if a sound one is already in hand, and never a
+     * resolution.
+     * <p>
+     * For callers on a path that must not block: {@link #project()} runs Maven
+     * when the stamp has moved, which is seconds, and the registration
+     * connection is being answered on the thread that would wait for it.
+     * <p>
+     * The fallback does not count. A resolution that wrote a current stamp and
+     * then failed to be read back leaves the application module alone standing
+     * in for the project, and a caller that builds on that builds on the wrong
+     * module set - which the next apply then reports as "module set changed"
+     * with no pom edit behind it. Such a caller is better off waiting for the
+     * apply that can resolve properly.
+     *
+     * @return the current project, or empty if resolving - or resolving again -
+     *         is what it would take to have a sound one
+     */
+    Optional<Project> projectIfResolved() {
+        Project current = project;
+        return current != null && !classpathUnusable && stampIsCurrent()
+                ? Optional.of(current)
+                : Optional.empty();
+    }
+
+    /**
+     * The daemon's own sink, for a caller that has nobody else to report to.
+     * <p>
+     * Work triggered by an application registering has no client waiting on it,
+     * and what it has to say belongs in {@code daemon.log} rather than nowhere.
+     */
+    Log log() {
+        return log;
+    }
+
     /**
      * Set when {@link #project()} last had to fall back; empty when it is
      * sound.