Compiling again but highlighting wrong.

app/src/processing/app/Problem.java

@@ -70,17 +70,17 @@ public interface Problem {
    * Get the exact character on which this problem starts in code line relative.
    * 
    * @return Number of characters past the start of the line if known where the
-   *    code associated with the Problem starts. Returns empty if not provided.
+   *    code associated with the Problem starts.
    */
-  public Optional<Integer> getStartOffset();
+  public int getStartOffset();
 
   /**
    * Get the exact character on which this problem ends in code line relative.
    * 
    * @return Number of characters past the start of the line if known where the
-   *    code associated with the Problem ends. Returns empty if not provided.
+   *    code associated with the Problem ends.
    */
-  public Optional<Integer> getStopOffset();
+  public int getStopOffset();
 
 }
 

app/src/processing/app/syntax/PdeTextAreaPainter.java

@@ -46,8 +46,6 @@ public class PdeTextAreaPainter extends TextAreaPainter {
   protected Color gutterTextInactiveColor;
   protected Color gutterHighlightColor;
 
-  private final Problem.LineToTabOffsetGetter lineToTabOffsetGetter;
-
 
   public PdeTextAreaPainter(JEditTextArea textArea, TextAreaDefaults defaults) {
     super(textArea, defaults);
@@ -78,10 +76,6 @@ public class PdeTextAreaPainter extends TextAreaPainter {
         }
       }
     });
-
-    lineToTabOffsetGetter = (x) -> {
-      return textArea.getLineStartOffset(x);
-    };
   }
 
 
@@ -153,12 +147,12 @@ public class PdeTextAreaPainter extends TextAreaPainter {
   protected void paintErrorLine(Graphics gfx, int line, int x) {
     List<Problem> problems = getEditor().findProblems(line);
     for (Problem problem : problems) {
-      int startOffset = problem.computeTabStartOffset(lineToTabOffsetGetter);
-      int stopOffset = problem.computeTabStopOffset(lineToTabOffsetGetter);
-
       int lineOffsetStart = textArea.getLineStartOffset(line);
       int lineOffsetStop = textArea.getLineStopOffset(line);
 
+      int startOffset = lineOffsetStart + problem.getStartOffset();
+      int stopOffset = lineOffsetStart + problem.getStopOffset();
+
       int wiggleStart = Math.max(startOffset, lineOffsetStart);
       int wiggleStop = Math.min(stopOffset, lineOffsetStop);
 
@@ -338,8 +332,8 @@ public class PdeTextAreaPainter extends TextAreaPainter {
         int lineStart = textArea.getLineStartOffset(line);
         int lineEnd = textArea.getLineStopOffset(line);
 
-        int errorStart = problem.computeTabStartOffset(lineToTabOffsetGetter);
-        int errorEnd = problem.computeTabStopOffset(lineToTabOffsetGetter) + 1;
+        int errorStart = lineStart + problem.getStartOffset();
+        int errorEnd = lineStart + problem.getStopOffset();
 
         int startOffset = Math.max(errorStart, lineStart) - lineStart;
         int stopOffset = Math.min(errorEnd, lineEnd) - lineStart;

app/src/processing/app/ui/Editor.java

@@ -2556,16 +2556,16 @@ public abstract class Editor extends JFrame implements RunnerListener {
 
 
   public void highlight(Problem p) {
-    Problem.LineToTabOffsetGetter getter = (x) -> {
-      return textarea.getLineStartOffset(x);
-    };
-
-    if (p != null) {
-      int tabIndex = p.getTabIndex();
-      int tabToStartOffset = p.computeTabStartOffset(getter);
-      int tabToStopOffset = p.computeTabStopOffset(getter);
-      highlight(tabIndex, tabToStartOffset, tabToStopOffset);
+    if (p == null) {
+      return;
     }
+
+    int tabIndex = p.getTabIndex();
+    int lineNumber = p.getLineNumber();
+    int lineStart = textarea.getLineStartOffset(lineNumber);
+    int tabToStartOffset = lineStart + p.getStartOffset();
+    int tabToStopOffset = lineStart + p.getStopOffset();
+    highlight(tabIndex, tabToStartOffset, tabToStopOffset);
   }
 
 
@@ -2630,9 +2630,8 @@ public abstract class Editor extends JFrame implements RunnerListener {
         .filter(p -> p.getTabIndex() == currentTab)
         .filter(p -> {
           int pStartLine = p.getLineNumber();
-          int pEndOffset = p.computeTabStopOffset(
-            (startLine) -> textarea.getLineStartOffset(pStartLine)
-          );
+          int lineOffset = textarea.getLineOfOffset(pStartLine);
+          int pEndOffset = lineOffset + p.getStopOffset();
           int pEndLine = textarea.getLineOfOffset(pEndOffset);
 
           return line >= pStartLine && line <= pEndLine;

java/src/processing/mode/java/JavaProblem.java

@@ -20,8 +20,6 @@ along with this program; if not, write to the Free Software Foundation, Inc.
 
 package processing.mode.java;
 
-import java.util.Optional;
-
 import org.eclipse.jdt.core.compiler.IProblem;
 
 import processing.app.Problem;
@@ -44,9 +42,9 @@ public class JavaProblem implements Problem {
   /** Line number (pde code) of the error */
   private final int lineNumber;
 
-  private Optional<Integer> startOffset;
+  private int startOffset;
 
-  private Optional<Integer> stopOffset;
+  private int stopOffset;
 
   /**
    * If the error is a 'cannot find type' contains the list of suggested imports
@@ -62,8 +60,6 @@ public class JavaProblem implements Problem {
     this.type = type;
     this.tabIndex = tabIndex;
     this.lineNumber = lineNumber;
-    this.startOffset = Optional.empty();
-    this.stopOffset = Optional.empty();
   }
 
 
@@ -87,32 +83,22 @@ public class JavaProblem implements Problem {
 
 
   public void setPDEOffsets(int startOffset, int stopOffset){
-    this.startOffset = Optional.of(startOffset);
-    this.stopOffset = Optional.of(stopOffset);
+    this.startOffset = startOffset;
+    this.stopOffset = stopOffset;
   }
 
 
   @Override
-  public Optional<Integer> getTabStartOffset() {
+  public int getStartOffset() {
     return startOffset;
   }
 
 
   @Override
-  public Optional<Integer> getTabStopOffset() {
+  public int getStopOffset() {
     return stopOffset;
   }
 
-  @Override
-  public Optional<Integer> getLineStartOffset() {
-    return Optional.empty();
-  }
-
-  @Override
-  public Optional<Integer> getLineStopOffset() {
-    return Optional.empty();
-  }
-
   @Override
   public boolean isError() {
     return type == ERROR;
@@ -163,36 +149,4 @@ public class JavaProblem implements Problem {
         + message;
   }
 
-  @Override
-  public int computeTabStartOffset(LineToTabOffsetGetter strategy) {
-    Optional<Integer> nativeTabStartOffset = getTabStartOffset();
-    if (nativeTabStartOffset.isPresent()) {
-      return nativeTabStartOffset.get();
-    }
-
-    Optional<Integer> lineStartOffset = getLineStartOffset();
-    int lineOffset = strategy.get(getLineNumber());
-    if (lineStartOffset.isPresent()) {
-      return lineOffset + lineStartOffset.get();
-    } else {
-      return lineOffset;
-    }
-  }
-
-  @Override
-  public int computeTabStopOffset(LineToTabOffsetGetter strategy) {
-    Optional<Integer> nativeTabStopOffset = getTabStopOffset();
-    if (nativeTabStopOffset.isPresent()) {
-      return nativeTabStopOffset.get();
-    }
-
-    Optional<Integer> lineStopOffset = getLineStopOffset();
-    int lineOffset = strategy.get(getLineNumber());
-    if (lineStopOffset.isPresent()) {
-      return lineOffset + lineStopOffset.get();
-    } else {
-      return lineOffset;
-    }
-  }
-
 }

java/src/processing/mode/java/SyntaxProblem.java

@@ -29,10 +29,8 @@ public class SyntaxProblem extends JavaProblem  {
   private final int tabIndex;
   private final int lineNumber;
   private final String message;
-  private final Optional<Integer> tabStartOffset;
-  private final Optional<Integer> tabStopOffset;
-  private final Optional<Integer> lineStartOffset;
-  private final Optional<Integer> lineStopOffset;
+  private final int lineStartOffset;
+  private final int lineStopOffset;
 
   /**
    * Create a new syntax problem.
@@ -40,33 +38,19 @@ public class SyntaxProblem extends JavaProblem  {
    * @param newTabIndex The tab number containing the source with the syntax issue.
    * @param newLineNumber The line number within the tab at which the offending code can be found.
    * @param newMessage Human readable message describing the issue.
-   * @param newStartOffset The character index at which the issue starts. This is relative to start
-   *    of tab / file not relative to start of line if newUsesLineOffset is true else it is line
-   *    offset.
-   * @param newStopOffset The character index at which the issue ends. This is relative to start
-   *    of tab / file not relative to start of line if newUsesLineOffset is true else it is line
-   *    offset.
+   * @param newStartOffset The character index at which the issue starts relative to line.
+   * @param newStopOffset The character index at which the issue end relative to line.
    */
   public SyntaxProblem(int newTabIndex, int newLineNumber, String newMessage, int newStartOffset,
-                       int newStopOffset, boolean newUsesLineOffset) {
+                       int newStopOffset) {
 
     super(newMessage, JavaProblem.ERROR, newLineNumber, newLineNumber);
 
     tabIndex = newTabIndex;
     lineNumber = newLineNumber;
     message = newMessage;
-
-    if (newUsesLineOffset) {
-      lineStartOffset = Optional.of(newStartOffset);
-      lineStopOffset = Optional.of(newStopOffset);
-      tabStartOffset = Optional.empty();
-      tabStopOffset = Optional.empty();
-    } else {
-      lineStartOffset = Optional.empty();
-      lineStopOffset = Optional.empty();
-      tabStartOffset = Optional.of(newStartOffset);
-      tabStopOffset = Optional.of(newStopOffset);
-    }
+    lineStartOffset = newStartOffset;
+    lineStopOffset = newStopOffset;
   }
 
   @Override
@@ -94,23 +78,11 @@ public class SyntaxProblem extends JavaProblem  {
     return message;
   }
 
-  @Override
-  public Optional<Integer> getTabStartOffset() {
-    return tabStartOffset;
-  }
-
-  @Override
-  public Optional<Integer> getTabStopOffset() {
-    return tabStopOffset;
-  }
-
-  @Override
-  public Optional<Integer> getLineStartOffset() {
+  public int getStartOffset() {
     return lineStartOffset;
   }
 
-  @Override
-  public Optional<Integer> getLineStopOffset() {
+  public int getStopOffset() {
     return lineStopOffset;
   }
 

java/src/processing/mode/java/lsp/PdeAdapter.java

@@ -229,24 +229,21 @@ class PdeAdapter {
       .map(prob -> {
         SketchCode code = sketch.getCode(prob.getTabIndex());
 
-        Optional<Integer> startOffset = prob.getTabStartOffset();
-        Optional<Integer> endOffset = prob.getTabStopOffset();
-
-        assert startOffset.isPresent();
-        assert endOffset.isPresent();
+        int startOffset = prob.getStartOffset();
+        int endOffset = prob.getStopOffset();
 
         Diagnostic dia = new Diagnostic(
           new Range(
             new Position(
               prob.getLineNumber(),
               PdeAdapter
-                .toLineCol(code.getProgram(), startOffset.get())
+                .toLineCol(code.getProgram(), startOffset)
                 .col - 1
             ),
             new Position(
               prob.getLineNumber(),
               PdeAdapter
-                .toLineCol(code.getProgram(), endOffset.get())
+                .toLineCol(code.getProgram(), endOffset)
                 .col - 1
             )
           ),