--- a/rules/convert/comments.rules
+++ b/rules/convert/comments.rules
@@ -25,6 +25,11 @@
** 008 CA 20200412 Added incremental conversion support.
** 009 CA 20200428 Legacy DEFINE ENUM conversion support.
** 010 AOG 20250313 Escape unicode sequence if it has not already been escaped.
+** 011 PMP 20260812 Search past neighbor nodes which earlier conversion rules deleted from the
+** tree (e.g. adjacent string literals folded into a single node). Their IDs are
+** still referenced by the shadow node linkage, so a comment surrounded by them
+** was reported as orphaned and dropped. Added the adjacentLive and
+** stepOverDeleted functions and made findNonWS hop over the deleted nodes.
*/
-->
@@ -164,7 +169,13 @@
-
+
+
+
+
+
+
+
+
+
+
+
+ next = null
+ local = ref.getLocal()
+
+ local != null
+ right
+ next = local.getRightShadowNode(deleted)
+ next = local.getLeftShadowNode(deleted)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ liveid = null
+ probe = shadow
+
+ probe != null
+
+ cand = probe.getAdjacentNonShadow(right)
+
+ cand == null
+
+
+
+ node = getAst(cand)
+
+ node != null
+ liveid = cand
+
+
+
+
+
+ probe = execLib("stepOverDeleted", probe.node, cand, right)
+
+
+
+
+
+ DOT) or a non-shadow node which is still part of the tree -->
-
+
+
-
+
nonWSNode = null
-
- right
- ref = shadow.node.rightShadowNode
- ref = shadow.node.leftShadowNode
-
-
-
- ref != null
-
-
+ probe = shadow
+
+
+ probe != null
+
+
- ref.type != prog.ws and
- ref.type != prog.tilde and
- ref.type != prog.backslash
-
-
- nonWSNode = ref
+ probe.node.id != shadow.node.id and
+ probe.node.type != prog.ws and
+ probe.node.type != prog.tilde and
+ probe.node.type != prog.backslash
+
+ nonWSNode = probe.node
-
+
right
- ref = ref.rightShadowNode
- ref = ref.leftShadowNode
+ ref = probe.node.rightShadowNode
+ ref = probe.node.leftShadowNode
-
-
- nonWSNode == null
- lastid = shadow.getAdjacentNonShadow(right)
- lastid != null
- nonWSNode = getAst(lastid)
+
+
+ ref != null
+
+
+
+ ref.type != prog.ws and
+ ref.type != prog.tilde and
+ ref.type != prog.backslash
+
+
+ nonWSNode = ref
+
+
+
+ right
+ ref = ref.rightShadowNode
+ ref = ref.leftShadowNode
+
+
+
+ nonWSNode != null
+
-
-
+
+ lastid = probe.getAdjacentNonShadow(right)
+
+ lastid == null
+
+
+
+ nonWSNode = getAst(lastid)
+
+ nonWSNode != null
+
+
+
+
+
+ probe = execLib("stepOverDeleted", probe.node, lastid, right)
+
+
+
+ ref != null and ref.line == line
nonWS = true
@@ -936,7 +1046,7 @@
attachId == -1 and leftNonWS != null
- lastid = shadow.getAdjacentNonShadow(false)
+ lastid = execLib("adjacentLive", shadow, false)
lastid != null
ref = execLib("getPeer", lastid)
ref != null and shadow.node.line == ref.line
@@ -1043,12 +1153,15 @@
!curDone and attachId == -1
- lastid = shadow.getAdjacentNonShadow(true)
-
+ lastid = execLib("adjacentLive", shadow, true)
+
- lastid != null and rightNonWS.id == lastid
+
+ lastid != null and
+ rightNonWS != null and
+ rightNonWS.id == lastid
ref = execLib("getPeer", lastid)
ref != null
@@ -1087,9 +1200,9 @@
attachId == -1
- lastid = shadow.getAdjacentNonShadow(false)
+ lastid = execLib("adjacentLive", shadow, false)
-
+
lastid != null
ref = execLib("getPeer", lastid)
ref != null
@@ -1129,9 +1242,37 @@
-
-
+ attachId == -1
+ lastid = execLib("adjacentLive", shadow, true)
+
+ lastid == null
+ lastid = execLib("adjacentLive", shadow, false)
+
+
+ lastid != null
+ ref = execLib("getPeer", lastid)
+ ref != null
+ parRef = execLib("getPeerParent", ref)
+ parRef.parent != null
+ attachId = parRef.parent.id
+ idx = parRef.indexPos
+
+
+
+ attachId = ref.parent.id
+ idx = ref.indexPos
+
+
+
+
+
attachId == -1
--- a/src/com/goldencode/p2j/pattern/AstSymbolResolver.java
+++ b/src/com/goldencode/p2j/pattern/AstSymbolResolver.java
@@ -131,6 +131,8 @@
** DDF 20250814 Moved getPathToConversionFolder() to ArtifactManager.
** DDF 20251022 Renamed methods.
** DDF 20251208 Used wildcards for imports.
+** 041 PMP 20260812 Never reload a tree which is already registered. Doing so replaced the
+** live nodes in the registry with stale copies read back from disk.
*/
/*
@@ -292,6 +294,9 @@
/** Map of ids to ASTs */
private Map astMap = new HashMap<>();
+ /** Tree ids of the trees which have been registered in {@link #astMap} */
+ private Set registeredTrees = new HashSet<>();
+
/** Set of filtered results which define a view on the original AST */
private Set view = null;
@@ -380,6 +385,7 @@
final Aast ast = AstManager.get().loadTree(artifact);
resolver.registerTree(ast);
+ resolver.markTreeRegistered(ast);
return ast;
}
@@ -419,6 +425,15 @@
return ast;
}
+ // the enclosing tree is already registered, so the node was deleted from that tree during
+ // the current processing (e.g. a literal folded away by expression conversion); reloading
+ // would register the stale nodes read back from the file in place of the live ones, which
+ // silently discards every annotation added since the tree was last persisted
+ if (resolver.isTreeRegistered(id))
+ {
+ return null;
+ }
+
// the AST was not found among those already loaded and registered; load the enclosing
// tree and try again
Artifact artifact = AstManager.get().getTreeArtifact(id);
@@ -1275,12 +1290,14 @@
if (copyAst != null && copyAst.isRoot())
{
registerTree(copyAst);
+ markTreeRegistered(copyAst);
}
// The target nodes need to be "brought along" too.
if (targetRootAst != null)
{
registerTree(targetRootAst);
+ markTreeRegistered(targetRootAst);
}
}
}
@@ -1309,6 +1326,13 @@
*/
public void deregisterTree(Aast root)
{
+ Long rootId = root.getId();
+
+ if (rootId != null)
+ {
+ registeredTrees.remove(AstManager.get().getTreeId(rootId));
+ }
+
Iterator iter = root.iterator();
while (iter.hasNext())
{
@@ -1323,11 +1347,45 @@
}
/**
+ * Check whether the tree which encloses the node with the given ID has been registered with
+ * this resolver. A node ID which belongs to a registered tree but which is absent from
+ * {@link #astMap} identifies a node that no longer exists in that tree.
+ *
+ * @param id
+ * The project-unique ID of an AST node.
+ *
+ * @return true if the enclosing tree is registered.
+ */
+ public boolean isTreeRegistered(Long id)
+ {
+ return id != null && registeredTrees.contains(AstManager.get().getTreeId(id));
+ }
+
+ /**
+ * Record that every node of the tree rooted at the given node has been registered with this
+ * resolver. Only complete trees may be recorded; registering a subtree leaves the rest of
+ * the enclosing tree unresolvable, which must still be handled by loading it from its file.
+ *
+ * @param root
+ * Root node of a complete tree which has just been registered.
+ */
+ private void markTreeRegistered(Aast root)
+ {
+ Long rootId = (root == null) ? null : root.getId();
+
+ if (rootId != null)
+ {
+ registeredTrees.add(AstManager.get().getTreeId(rootId));
+ }
+ }
+
+ /**
* Clean up internal resources.
*/
void cleanUp()
{
astMap = new HashMap<>();
+ registeredTrees = new HashSet<>();
setRuleScope(engine.get());
}