Merge pull request #6905 from chrisrueger/warn-single-backslash-sourceeditor

source editor: warning on single backslashes

Author: chrisrueger

aQute.libg/src/aQute/lib/utf8properties/PropertiesParser.java

@@ -371,9 +371,6 @@ private char backslash() {
 					return (char) Integer.parseInt(unicode, 16);
 				}
 
-			case ':' :
-			case '=' :
-				return c;
 			case 't' :
 				return '\t';
 			case 'f' :
@@ -384,15 +381,29 @@ private char backslash() {
 				return '\n';
 			case '\\' :
 				return '\\';
+			case ':' :
+			case '=' :
+			case '#' :
+			case '!' :
+				return c;
 
-			case '\f' :
-			case '\t' :
 			case ' ' :
+			case '\t' :
+				// whitespace immediately after backslash
 				warning(
 					"Found \\<whitespace>. This is allowed in a properties file but not in bnd to prevent mistakes");
 				return c;
 
 			default :
+				// any other character after backslash not forming a valid
+				// escape -> warning
+				if ("tnrf\\'\":=#!".indexOf(c) >= 0 || c == 'u') {
+					// valid escape -> no warning
+					return c;
+				}
+				warning(
+					"Found odd number of backslashes before '%s'. These are silently dropped by Java properties parsing and lead to confusing behavior",
+					c);
 				return c;
 		}
 	}

aQute.libg/test/aQute/lib/utf8properties/UTF8PropertiesTest.java

@@ -296,6 +296,11 @@ public void testErrorsInParsing() throws IOException {
 			+ "a;b=9", "a;b", 7, "Invalid property key: `a;b`:");
 		assertError("\n" //
 			+ "a=\\ \n     a;v=4", "a", 1, "Found \\\\<whitespace>", "Invalid property key: `a;v`");
+		assertError("\n" //
+			+ "a=\\abc\n", "a", 1, "Found odd number of backslashes before");
+		assertError("\n" //
+			+ "a=\\u12G4", "a", 1, "Invalid unicode string");
+
 		assertError("\n\n\n\n\n\n\n" //
 			+ "a", "a", 7, "No value specified for key");
 		assertError("\npropertyName=property\0Value\n", "propertyName", 1,

bndtools.core/src/bndtools/editor/completion/BackslashValidator.java

@@ -0,0 +1,156 @@
+package bndtools.editor.completion;
+
+import org.eclipse.jface.text.rules.ICharacterScanner;
+
+import aQute.lib.hex.Hex;
+
+public final class BackslashValidator {
+
+    public enum Result {
+        UNDEFINED,    // valid escape or even run
+        ERROR,        // invalid backslash sequence (e.g., \ followed by space)
+        REFRESH       // odd backslash at EOF, to refresh partition
+    }
+
+	/**
+	 * Handles a sequence of backslashes and determines whether it forms a valid
+	 * escape, line continuation, or an error sequence.
+	 * <p>
+	 * Rules:
+	 * <ul>
+	 * <li>Even-length runs of backslashes are always valid (all characters are
+	 * unread).</li>
+	 * <li>Odd-length runs are followed by:
+	 * <ul>
+	 * <li>Line breaks (\n or \r) → valid line continuation, unread buffer,
+	 * return UNDEFINED</li>
+	 * <li>EOF → return T_DEFAULT to refresh partition in Eclipse (prevents
+	 * sticky red)</li>
+	 * <li>Space or tab → invalid sequence, consume spaces, return T_ERROR</li>
+	 * <li>Valid escape characters (\t, \n, \r, \f, \\, :, =, #, !, or Unicode
+	 * \\uXXXX) → unread buffer, return UNDEFINED</li>
+	 * <li>Anything else → invalid, return T_ERROR</li>
+	 * </ul>
+	 * </li>
+	 * </ul>
+	 * <p>
+	 * The method always maintains scanner consistency by using a buffer to
+	 * unread non-error characters, ensuring the scanner position is restored.
+	 *
+	 * @param scanner the character scanner
+	 * @param first the first character read (must be a backslash to enter
+	 *            processing)
+	 * @return a token indicating UNDEFINED, T_ERROR, or T_DEFAULT for EOF
+	 */
+	public static Result handleBackslashes(ICharacterScanner scanner, int first) {
+		StringBuilder buffer = new StringBuilder();
+		buffer.append((char) first);
+
+		// dbg("handleBackspaces(): first='%c' (%d)", first, first);
+
+		if (first != '\\') {
+			unreadBuffer(scanner, buffer);
+			// dbg("not a backslash → UNDEFINED");
+			return Result.UNDEFINED;
+		}
+
+		int c;
+		// count consecutive backslashes
+		int runLen = 1;
+		while (true) {
+			int peek = scanner.read();
+			if (peek == ICharacterScanner.EOF || peek != '\\') {
+				c = peek; // next char after run
+				break;
+			}
+			buffer.append((char) peek);
+			runLen++;
+		}
+		boolean odd = (runLen & 1) == 1;
+
+		if (!odd) {
+			unreadBuffer(scanner, buffer); // even run → unread everything
+			// dbg("even runLen=%d → UNDEFINED", runLen);
+			return Result.UNDEFINED;
+		}
+
+		// odd backslash → check next char
+		if (c == '\n' || c == '\r') {
+			unreadBuffer(scanner, buffer);
+			// dbg("odd backslash but line continuation → UNDEFINED");
+			return Result.UNDEFINED;
+		}
+
+		if (c == ICharacterScanner.EOF) {
+			unreadBuffer(scanner, buffer);
+			// dbg("odd backslash at EOF → return T_DEFAULT to refresh
+			// partition");
+			return Result.REFRESH; // forces partition update
+		}
+
+		if (c == ' ' || c == '\t') {
+			// consume all spaces
+			do {
+				c = scanner.read();
+				if (c == ICharacterScanner.EOF)
+					break;
+				buffer.append((char) c);
+			} while (c == ' ' || c == '\t');
+
+			if (c != ICharacterScanner.EOF)
+				scanner.unread(); // unread first non-space
+
+			// dbg("invalid '\\ ' sequence → ERROR");
+			return Result.ERROR; // leave buffer consumed for error only
+		}
+
+		// Valid single-character escapes
+		if ("tnrf\\=:#!".indexOf(c) >= 0) {
+			unreadBuffer(scanner, buffer); // valid escape → unread everything
+			// dbg("valid escape '\\%c' → UNDEFINED", c);
+			return Result.UNDEFINED;
+
+		}
+
+		// Unicode escape
+		if (c == 'u') {
+			// unicode check borrowed from
+			// aQute.lib.utf8properties.PropertiesParser.backslash()
+			// read 4 hex digits after \\u
+			StringBuilder sb = new StringBuilder();
+			for (int i = 0; i < 4; i++) {
+				int ch = scanner.read();
+				if (ch == ICharacterScanner.EOF)
+					break;
+				sb.append((char) ch);
+			}
+			String unicode = sb.toString();
+			if (unicode.length() != 4 || !Hex.isHex(unicode)) {
+				// dbg("invalid unicode escape: \\u%s → ERROR", unicode);
+				unreadBuffer(scanner, buffer);
+				return Result.ERROR;
+			} else {
+				// dbg("valid unicode escape: \\u%s → UNDEFINED", unicode);
+				unreadBuffer(scanner, buffer);
+				return Result.UNDEFINED;
+			}
+		}
+
+		// dbg("anything else after odd '\\' → ERROR");
+		return Result.ERROR;
+    }
+
+	private static void unreadBuffer(ICharacterScanner scanner, StringBuilder buffer) {
+		for (int i = buffer.length() - 1; i >= 0; i--)
+			scanner.unread();
+		// dbg("unreadBuffer() → put back %d chars", buffer.length());
+	}
+
+	/**
+	 * for debug logging. Currently all callers comment for performance reasons.
+	 */
+	static void dbg(String fmt, Object... args) {
+		System.out.printf("[BndScanner] " + fmt + "%n", args);
+	}
+
+}

bndtools.core/src/bndtools/editor/completion/BndScanner.java

@@ -116,23 +116,77 @@ IToken keyword(ICharacterScanner scanner) {
 		return bsvc.T_KEY;
 	}
 
+
+	/**
+	 * Scans for invalid backslash sequences in a Java properties file and
+	 * returns a token indicating the type of content.
+	 * <p>
+	 * This method detects:
+	 * <ul>
+	 * <li>Single backslashes at the end of the line or before EOF (line
+	 * continuation)</li>
+	 * <li>Invalid sequences such as a backslash followed by a space or tab
+	 * (error)</li>
+	 * <li>Valid escape sequences like \t, \n, \r, \f, \\, \:, \=, \#, \!, and
+	 * Unicode \\uXXXX</li>
+	 * </ul>
+	 * <p>
+	 * Implementation notes:
+	 * <ul>
+	 * <li>The first character is read and checked for a backslash.</li>
+	 * <li>All consecutive backslashes are collected into a buffer.</li>
+	 * <li>If the number of consecutive backslashes is even, it is valid and
+	 * unread back into the scanner.</li>
+	 * <li>If odd, the next character determines whether it is a valid escape,
+	 * line continuation, or error.</li>
+	 * <li>Special handling for EOF: a single backslash at EOF returns T_DEFAULT
+	 * instead of UNDEFINED to force Eclipse to refresh the partition and
+	 * prevent "sticky red" highlighting.</li>
+	 * <li>Buffering ensures scanner state is fully restored for non-error
+	 * sequences.</li>
+	 * </ul>
+	 *
+	 * @param scanner the character scanner
+	 * @return a token representing either UNDEFINED, T_ERROR, or T_DEFAULT for
+	 *         a valid backslash at EOF
+	 */
 	IToken error(ICharacterScanner scanner) {
-		int c = scanner.read();
-		int n = 1;
-		if (c == '\\') {
-			c = scanner.read();
-			n++;
-			if (c == ' ' || c == '\t') {
-				while (c == ' ' || c == '\t') {
-					c = scanner.read();
-				}
-				scanner.unread();
+		int startColumn = scanner.getColumn();
+		int first = scanner.read();
+		// BackslashValidator.dbg("error() start col=%d first='%s' (code=%d)",
+		// startColumn,
+		// (first == ICharacterScanner.EOF ? "<EOF>" : Character.toString((char)
+		// first)), first);
+
+		if (first == ICharacterScanner.EOF) {
+			return Token.UNDEFINED;
+		}
+
+		IToken token = handleBackspaces(scanner, first);
+		// BackslashValidator.dbg("→ return token=%s at col=%d%n",
+		// token.isUndefined() ? "UNDEFINED" : token.getData(),
+		// scanner.getColumn());
+		return token;
+	}
+
+
+	private IToken handleBackspaces(ICharacterScanner scanner, int first) {
+
+		// Use the shared helper to determine the result
+		BackslashValidator.Result result = BackslashValidator.handleBackslashes(scanner, first);
+
+		switch (result) {
+			case UNDEFINED :
+				return Token.UNDEFINED;
+			case ERROR :
 				return bsvc.T_ERROR;
-			}
+			case REFRESH :
+				return bsvc.T_DEFAULT; // forces partition refresh
+			default :
+				return Token.UNDEFINED;
 		}
-		while (n-- > 0)
-			scanner.unread();
-		return Token.UNDEFINED;
 	}
 
+
+
 }