ANTLRv4 indent and code snippet support.

java/languages.antlr/src/org/netbeans/modules/languages/antlr/AntlrParserResult.java

@@ -64,7 +64,6 @@ public AntlrParserResult(Snapshot snapshot) {
 
     public AntlrParserResult get() {
         if (! finished) {
-            FileObject fo = getSnapshot().getSource().getFileObject();
             T parser = createParser(getSnapshot());
             parser.addErrorListener(createErrorListener());
             parser.addParseListener(createFoldListener());

java/languages.antlr/src/org/netbeans/modules/languages/antlr/layer.xml

@@ -41,6 +41,11 @@
                         </folder>
                     </folder>
                 </folder>
+                <folder name="Preferences">
+                    <folder name="Defaults">
+                        <file name="org-netbeans-modules-languages-antlr-v3-preferences.xml" url="v3/preferences.xml"/>
+                    </folder>
+                </folder>                
             </folder>
             <folder name="x-antlr4">
                 <attr name="displayName" bundlevalue="org.netbeans.modules.languages.antlr.Bundle#Editors/text/x-antlr4"/>
@@ -60,6 +65,14 @@
                         </folder>
                     </folder>
                 </folder>
+                <folder name="CodeTemplates">
+                    <file name="org-netbeans-modules-languages-antlr-v4-snippets.xml" url="v4/snippets.xml"/>
+                </folder>                
+                <folder name="Preferences">
+                    <folder name="Defaults">
+                        <file name="org-netbeans-modules-languages-antlr-v4-preferences.xml" url="v4/preferences.xml"/>
+                    </folder>
+                </folder>                
             </folder>
         </folder>
     </folder>

java/languages.antlr/src/org/netbeans/modules/languages/antlr/v3/Antlr3ParserResult.java

@@ -26,6 +26,7 @@
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.ConsoleErrorListener;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 import org.netbeans.modules.csl.api.OffsetRange;
@@ -50,7 +51,9 @@ protected ANTLRv3Parser createParser(Snapshot snapshot) {
         CharStream cs = CharStreams.fromString(String.valueOf(snapshot.getText()));
         ANTLRv3Lexer lexer = new ANTLRv3Lexer(cs);
         CommonTokenStream tokens = new CommonTokenStream(lexer);
-        return new ANTLRv3Parser(tokens);
+        ANTLRv3Parser ret = new ANTLRv3Parser(tokens);
+        ret.removeErrorListener(ConsoleErrorListener.INSTANCE);
+        return ret;
     }
 
     @Override

java/languages.antlr/src/org/netbeans/modules/languages/antlr/v3/preferences.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+-->
+<!DOCTYPE editor-preferences PUBLIC "-//NetBeans//DTD Editor Preferences 1.0//EN" "http://www.netbeans.org/dtds/EditorPreferences-1_0.dtd">
+
+<editor-preferences>
+    <entry category="private" name="custom-action-list" value="org.netbeans.modules.languages.yaml.InsertTabAction.createCustomActions" />
+    <entry javaType="java.lang.Boolean" name="enable-indent" xml:space="preserve"><value>true</value></entry>
+    <entry javaType="java.lang.Integer" name="indent-shift-width" xml:space="preserve"><value>4</value></entry>
+</editor-preferences>

java/languages.antlr/src/org/netbeans/modules/languages/antlr/v4/Antlr4CompletionProvider.java

@@ -33,8 +33,6 @@
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.Token;
 import org.netbeans.api.editor.document.EditorDocumentUtils;
-import org.netbeans.api.editor.document.LineDocument;
-import org.netbeans.api.editor.document.LineDocumentUtils;
 import org.netbeans.api.editor.mimelookup.MimeLookup;
 import org.netbeans.api.editor.mimelookup.MimePath;
 import org.netbeans.api.editor.mimelookup.MimeRegistration;
@@ -86,18 +84,6 @@ public AntlrCompletionQuery(boolean caseSensitive) {
             this.caseSensitive = caseSensitive;
         }
 
-        //TODO: This is a Lexer based pretty dumb implementation. Only offer
-        //      prefix if the cursor is at the end of a start of token/lexer rule.
-        //      Shall be replaced with a better approach.
-        private String getPrefix(Document doc, int caretOffset, boolean upToOffset) throws BadLocationException {
-            LineDocument lineDoc = LineDocumentUtils.asRequired(doc, LineDocument.class);
-            int start = LineDocumentUtils.getWordStart(lineDoc, caretOffset);
-            int end = LineDocumentUtils.getWordEnd(lineDoc, caretOffset);
-            String prefix = doc.getText(start, (upToOffset ? caretOffset : end) - start);
-
-            return (prefix.length() > 0) && !Character.isWhitespace(prefix.codePointAt(prefix.length() - 1)) ? prefix : "";
-        }
-
         @Override
         protected void query(CompletionResultSet resultSet, Document doc, int caretOffset) {
             AbstractDocument adoc = (AbstractDocument) doc;
@@ -143,12 +129,10 @@ protected void query(CompletionResultSet resultSet, Document doc, int caretOffse
                         tokens.previous();
                         lookAround(fo, tokens, caretOffset, prefix, resultSet);
                     } else {
-                        //Empty grammar so far offer lexer and grammar
-                        addTokens("", caretOffset, resultSet, "lexer", "grammar");
+                        //Empty grammar so far offer lexer, parser and grammar
+                        addTokens("", caretOffset, resultSet, "lexer", "parser", "grammar");
                     }
                 }
-            } catch (Throwable th) {
-                System.out.println(th);
             } finally {
                 resultSet.finish();
             }
@@ -162,6 +146,9 @@ private void lookAround(FileObject fo, AntlrTokenSequence tokens, int caretOffse
                 if (t.isPresent() && t.get().getType() != LEXER) {
                     addTokens(prefix, caretOffset, resultSet, "lexer");
                 }                
+                if (t.isPresent() && t.get().getType() != PARSER) {
+                    addTokens(prefix, caretOffset, resultSet, "parser");
+                }                
                 if (t.isPresent() && (t.get().getType() != LEXER) && (t.get().getType() != GRAMMAR)) {
                     addTokens(prefix, caretOffset, resultSet, "grammar");
                 }
@@ -174,11 +161,12 @@ private void lookAround(FileObject fo, AntlrTokenSequence tokens, int caretOffse
                     opt = tokens.previous(DEFAULT_CHANNEL);
                 }
                 if (!opt.isPresent()) {
-                    addTokens(prefix, caretOffset, resultSet, "lexer", "grammar");
+                    addTokens(prefix, caretOffset, resultSet, "lexer", "parser", "grammar");
                     return;
                 } else {
                     pt = opt.get();
                     switch (pt.getType()) {
+                        case PARSER:
                         case LEXER:
                             Optional<Token> t = tokens.next(DEFAULT_CHANNEL);
                             if (!t.isPresent() || t.get().getType() != GRAMMAR) {

java/languages.antlr/src/org/netbeans/modules/languages/antlr/v4/Antlr4Formatter.java

@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.netbeans.modules.languages.antlr.v4;
+
+import java.util.prefs.Preferences;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+import org.antlr.parser.antlr4.ANTLRv4Lexer;
+import org.antlr.v4.runtime.CharStreams;
+import org.netbeans.modules.csl.api.Formatter;
+import org.netbeans.modules.csl.spi.ParserResult;
+import org.netbeans.modules.editor.indent.spi.Context;
+
+import static org.antlr.parser.antlr4.ANTLRv4Lexer.*;
+import org.antlr.v4.runtime.Token;
+import org.netbeans.api.editor.document.LineDocument;
+import org.netbeans.api.editor.document.LineDocumentUtils;
+import org.netbeans.api.editor.settings.SimpleValueNames;
+import org.netbeans.modules.editor.indent.spi.CodeStylePreferences;
+
+/**
+ *
+ * @author lkishalmi
+ */
+public class Antlr4Formatter implements Formatter {
+
+    public Antlr4Formatter() {
+    }
+
+    @Override
+    public void reformat(Context context, ParserResult compilationInfo) {
+        LineDocument doc = LineDocumentUtils.as(context.document(), LineDocument.class);
+        String text;
+        int indentSize = getIndentSize(context.document());
+        try {
+            text = doc.getText(0, doc.getLength());
+        } catch (BadLocationException ex) {
+            return;
+        }
+
+        ANTLRv4Lexer lexer = new ANTLRv4Lexer(CharStreams.fromString(text));
+        Token token = lexer.nextToken();
+        if (token.getType() == EOF) {
+            return;
+        }
+
+        final int cstart = context.startOffset();
+        final int cend = context.endOffset();
+
+        int tstart = token.getStartIndex();
+        int tstop = token.getStopIndex();
+
+        try {
+            boolean inRule = false;
+            int ruleLine = 0;
+            int parenDepth = 0;
+            int textDelta = 0;
+            int prevTokenType = -1;
+            while ((token.getType() != EOF) && (tstart < cend)) {
+                switch (token.getType()) {
+                    case RULE_REF:
+                    case TOKEN_REF:
+                        // @header , @member, etc, are not real rules;
+                        if (!inRule && (prevTokenType != AT)) {
+                            inRule = true;
+                        }
+                        break;
+                    case LPAREN:
+                        parenDepth++;
+                        break;
+                    case RPAREN:
+                        parenDepth--;
+                        break;
+                    case SEMI:
+                        inRule = false;
+                        break;
+                }
+                if (tstop >= cstart) {
+                    if (!context.isIndent()) {
+                        //TODO: Do non-indent formatting
+                    }
+                    if (token.getChannel() == OFF_CHANNEL) {
+                        String ttext = token.getText();
+                        int nl = ttext.indexOf('\n');
+                        while ((nl != -1) && (tstart + nl <= cend))  {
+                            int lineStart = context.lineStartOffset(tstart + textDelta + nl);
+                            if (inRule || ruleLine > 0) {
+                                if (tstart + nl >= cstart) {
+                                    // Indent the first rule line to 0 the rest to indentSize
+                                    int originalIndent = context.lineIndent(lineStart);
+                                    int newIndent = ruleLine > 0 ? indentSize : 0;
+                                    context.modifyIndent(lineStart, newIndent);
+                                    textDelta += newIndent - originalIndent;
+                                }
+                                ruleLine = inRule ? ruleLine + 1 : 0;
+                            }
+                            nl = ttext.indexOf('\n', nl + 1);
+                        }
+                    }
+                }
+                prevTokenType = token.getType();
+                token = lexer.nextToken();
+                tstart = token.getStartIndex();
+                tstop = token.getStopIndex();
+            }
+        } catch (BadLocationException ex) {}
+    }
+
+    @Override
+    public void reindent(Context context) {
+        reformat(context, null);
+    }
+
+    @Override
+    public boolean needsParserResult() {
+        return false;
+    }
+
+    @Override
+    public int indentSize() {
+        return 4;
+    }
+
+    @Override
+    public int hangingIndentSize() {
+        return 4;
+    }
+
+    static int getIndentSize(Document doc) {
+        Preferences prefs = CodeStylePreferences.get(doc).getPreferences();
+        return prefs.getInt(SimpleValueNames.INDENT_SHIFT_WIDTH, 4);
+    }
+}

java/languages.antlr/src/org/netbeans/modules/languages/antlr/v4/Antlr4Language.java

@@ -23,6 +23,7 @@
 import org.netbeans.core.spi.multiview.MultiViewElement;
 import org.netbeans.core.spi.multiview.text.MultiViewEditorElement;
 import org.netbeans.modules.csl.api.DeclarationFinder;
+import org.netbeans.modules.csl.api.Formatter;
 import org.netbeans.modules.csl.api.OccurrencesFinder;
 import org.netbeans.modules.csl.api.StructureScanner;
 import org.netbeans.modules.csl.spi.DefaultLanguageConfig;
@@ -131,6 +132,16 @@ public String getDisplayName() {
         return Bundle.ANTLRv4Resolver();
     }
 
+    @Override
+    public Formatter getFormatter() {
+        return new Antlr4Formatter();
+    }
+
+    @Override
+    public boolean hasFormatter() {
+        return true;
+    }
+
     @Override
     public String getPreferredExtension() {
         return "g4";

java/languages.antlr/src/org/netbeans/modules/languages/antlr/v4/Antlr4ParserResult.java

@@ -31,6 +31,7 @@
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.ConsoleErrorListener;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 import org.antlr.v4.runtime.tree.TerminalNode;
@@ -64,7 +65,9 @@ protected ANTLRv4Parser createParser(Snapshot snapshot) {
         CharStream cs = CharStreams.fromString(String.valueOf(snapshot.getText()));
         ANTLRv4Lexer lexer = new org.antlr.parser.antlr4.ANTLRv4Lexer(cs);
         CommonTokenStream tokens = new CommonTokenStream(lexer);
-        return new ANTLRv4Parser(tokens);
+        ANTLRv4Parser ret = new ANTLRv4Parser(tokens);
+        ret.removeErrorListener(ConsoleErrorListener.INSTANCE);
+        return ret;
     }
 
     @Override
@@ -82,14 +85,18 @@ protected ParseTreeListener createReferenceListener() {
         return new ANTLRv4ParserBaseListener() {
             @Override
             public void exitParserRuleSpec(ANTLRv4Parser.ParserRuleSpecContext ctx) {
-                Token token = ctx.RULE_REF().getSymbol();
-                addReference(token);
+                if (ctx.RULE_REF() != null) {
+                    Token token = ctx.RULE_REF().getSymbol();
+                    addReference(token);
+                }
             }
 
             @Override
             public void exitLexerRuleSpec(ANTLRv4Parser.LexerRuleSpecContext ctx) {
-                Token token = ctx.TOKEN_REF().getSymbol();
-                addReference(token);
+                if (ctx.TOKEN_REF() != null) {
+                    Token token = ctx.TOKEN_REF().getSymbol();
+                    addReference(token);
+                }
             }
 
             @Override
@@ -112,7 +119,9 @@ public void exitChannelsSpec(ANTLRv4Parser.ChannelsSpecContext ctx) {
 
             @Override
             public void exitModeSpec(ANTLRv4Parser.ModeSpecContext ctx) {
-                addReference(getIdentifierToken(ctx.identifier()));
+                if (ctx.identifier() != null) {
+                    addReference(getIdentifierToken(ctx.identifier()));
+                }
             }
 
             public void addReference(Token token) {
@@ -311,7 +320,9 @@ public void exitRuleref(ANTLRv4Parser.RulerefContext ctx) {
 
         @Override
         public void exitLexerCommandExpr(ANTLRv4Parser.LexerCommandExprContext ctx) {
-            onOccurance.accept(getIdentifierToken(ctx.identifier()));
+            if (ctx.identifier() != null) {
+                onOccurance.accept(getIdentifierToken(ctx.identifier()));
+            }
         }