ilyakooo0/intellij-haskell
1
0
Fork 0
mirror of https://github.com/ilyakooo0/intellij-haskell.git synced 2024-09-11 14:56:19 +03:00
Code Issues Projects Releases Wiki Activity

Implement new parser, close #382, close #332

Browse Source
This commit is contained in:
ice1000 2019-02-17 00:09:34 -05:00
parent cffaaeacf7
commit 66be49d6cb
17 changed files with 668 additions and 738 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

161
gen/intellij/haskell/parser/HaskellParser.java
View File

@ -139,8 +139,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
r = newconstr_fielddecl(b, 0);
} else if (t == HS_NEWTYPE_DECLARATION) {
r = newtype_declaration(b, 0);
} else if (t == HS_OPTIONS_GHC_PRAGMA) {
r = options_ghc_pragma(b, 0);
} else if (t == HS_OTHER_PRAGMA) {
r = other_pragma(b, 0);
} else if (t == HS_OVERLAP_PRAGMA) {
@ -2968,39 +2966,14 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// pragma NEWLINE | options_ghc_pragma NEWLINE | pragma | options_ghc_pragma
// pragma
public static boolean file_header_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "file_header_pragma")) return false;
if (!nextTokenIs(b, "<file header pragma>", HS_OPTIONS_GHC, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, HS_FILE_HEADER_PRAGMA, "<file header pragma>");
r = file_header_pragma_0(b, l + 1);
if (!r) r = file_header_pragma_1(b, l + 1);
if (!r) r = pragma(b, l + 1);
if (!r) r = options_ghc_pragma(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// pragma NEWLINE
private static boolean file_header_pragma_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "file_header_pragma_0")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
r = r && consumeToken(b, HS_NEWLINE);
exit_section_(b, m, null, r);
return r;
}
// options_ghc_pragma NEWLINE
private static boolean file_header_pragma_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "file_header_pragma_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = options_ghc_pragma(b, l + 1);
r = r && consumeToken(b, HS_NEWLINE);
exit_section_(b, m, null, r);
exit_section_(b, m, HS_FILE_HEADER_PRAGMA, r);
return r;
}
@ -3090,81 +3063,19 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// (CON_ID | VAR_ID | CONSYM_ID | VARSYM_ID |
// LEFT_PAREN | RIGHT_PAREN | FLOAT | UNDERSCORE |
// SEMICOLON | LEFT_BRACKET | RIGHT_BRACKET | literal | LEFT_BRACE | RIGHT_BRACE |
// COMMA | QUOTE | BACKQUOTE | NEWLINE | DOUBLE_QUOTE | TILDE | DOT | dot_dot | VERTICAL_BAR |
// EQUAL | DOUBLE_RIGHT_ARROW | COLON_COLON | RIGHT_ARROW | LEFT_ARROW | BACKSLASH | TYPE |
// INSTANCE | MODULE | WHERE | DO | LET | IN | CASE | OF | IF | THEN | ELSE | IMPORT | DIRECTIVE)+
// ONE_PRAGMA | PRAGMA_SEP | CHARACTER_LITERAL | STRING_LITERAL
public static boolean general_pragma_content(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "general_pragma_content")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, HS_GENERAL_PRAGMA_CONTENT, "<general pragma content>");
r = general_pragma_content_0(b, l + 1);
while (r) {
int c = current_position_(b);
if (!general_pragma_content_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "general_pragma_content", c)) break;
}
r = consumeToken(b, HS_ONE_PRAGMA);
if (!r) r = consumeToken(b, HS_PRAGMA_SEP);
if (!r) r = consumeToken(b, HS_CHARACTER_LITERAL);
if (!r) r = consumeToken(b, HS_STRING_LITERAL);
exit_section_(b, l, m, r, false, null);
return r;
}
// CON_ID | VAR_ID | CONSYM_ID | VARSYM_ID |
// LEFT_PAREN | RIGHT_PAREN | FLOAT | UNDERSCORE |
// SEMICOLON | LEFT_BRACKET | RIGHT_BRACKET | literal | LEFT_BRACE | RIGHT_BRACE |
// COMMA | QUOTE | BACKQUOTE | NEWLINE | DOUBLE_QUOTE | TILDE | DOT | dot_dot | VERTICAL_BAR |
// EQUAL | DOUBLE_RIGHT_ARROW | COLON_COLON | RIGHT_ARROW | LEFT_ARROW | BACKSLASH | TYPE |
// INSTANCE | MODULE | WHERE | DO | LET | IN | CASE | OF | IF | THEN | ELSE | IMPORT | DIRECTIVE
private static boolean general_pragma_content_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "general_pragma_content_0")) return false;
boolean r;
r = consumeToken(b, HS_CON_ID);
if (!r) r = consumeToken(b, HS_VAR_ID);
if (!r) r = consumeToken(b, HS_CONSYM_ID);
if (!r) r = consumeToken(b, HS_VARSYM_ID);
if (!r) r = consumeToken(b, HS_LEFT_PAREN);
if (!r) r = consumeToken(b, HS_RIGHT_PAREN);
if (!r) r = consumeToken(b, HS_FLOAT);
if (!r) r = consumeToken(b, HS_UNDERSCORE);
if (!r) r = consumeToken(b, HS_SEMICOLON);
if (!r) r = consumeToken(b, HS_LEFT_BRACKET);
if (!r) r = consumeToken(b, HS_RIGHT_BRACKET);
if (!r) r = literal(b, l + 1);
if (!r) r = consumeToken(b, HS_LEFT_BRACE);
if (!r) r = consumeToken(b, HS_RIGHT_BRACE);
if (!r) r = consumeToken(b, HS_COMMA);
if (!r) r = consumeToken(b, HS_QUOTE);
if (!r) r = consumeToken(b, HS_BACKQUOTE);
if (!r) r = consumeToken(b, HS_NEWLINE);
if (!r) r = consumeToken(b, HS_DOUBLE_QUOTE);
if (!r) r = consumeToken(b, HS_TILDE);
if (!r) r = consumeToken(b, HS_DOT);
if (!r) r = dot_dot(b, l + 1);
if (!r) r = consumeToken(b, HS_VERTICAL_BAR);
if (!r) r = consumeToken(b, HS_EQUAL);
if (!r) r = consumeToken(b, HS_DOUBLE_RIGHT_ARROW);
if (!r) r = consumeToken(b, HS_COLON_COLON);
if (!r) r = consumeToken(b, HS_RIGHT_ARROW);
if (!r) r = consumeToken(b, HS_LEFT_ARROW);
if (!r) r = consumeToken(b, HS_BACKSLASH);
if (!r) r = consumeToken(b, HS_TYPE);
if (!r) r = consumeToken(b, HS_INSTANCE);
if (!r) r = consumeToken(b, HS_MODULE);
if (!r) r = consumeToken(b, HS_WHERE);
if (!r) r = consumeToken(b, HS_DO);
if (!r) r = consumeToken(b, HS_LET);
if (!r) r = consumeToken(b, HS_IN);
if (!r) r = consumeToken(b, HS_CASE);
if (!r) r = consumeToken(b, HS_OF);
if (!r) r = consumeToken(b, HS_IF);
if (!r) r = consumeToken(b, HS_THEN);
if (!r) r = consumeToken(b, HS_ELSE);
if (!r) r = consumeToken(b, HS_IMPORT);
if (!r) r = consumeToken(b, HS_DIRECTIVE);
return r;
}
/* ********************************************************** */
// QUOTE? q_name | LEFT_PAREN RIGHT_ARROW RIGHT_PAREN | LEFT_PAREN RIGHT_PAREN | QUOTE? LEFT_BRACKET RIGHT_BRACKET | LEFT_PAREN COMMA (COMMA)* RIGHT_PAREN
public static boolean gtycon(PsiBuilder b, int l) {
@ -4847,18 +4758,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// OPTIONS_GHC
public static boolean options_ghc_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "options_ghc_pragma")) return false;
if (!nextTokenIs(b, HS_OPTIONS_GHC)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, HS_OPTIONS_GHC);
exit_section_(b, m, HS_OPTIONS_GHC_PRAGMA, r);
return r;
}
/* ********************************************************** */
// pragma
public static boolean other_pragma(PsiBuilder b, int l) {
@ -4884,7 +4783,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// PRAGMA_START (onl CON_ID? onl general_pragma_content? onl PRAGMA_END)+
// PRAGMA_START general_pragma_content* PRAGMA_END
static boolean pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
@ -4892,52 +4791,20 @@ public class HaskellParser implements PsiParser, LightPsiParser {
Marker m = enter_section_(b, l, _NONE_);
r = consumeToken(b, HS_PRAGMA_START);
p = r; // pin = 1
r = r && pragma_1(b, l + 1);
r = r && report_error_(b, pragma_1(b, l + 1));
r = p && consumeToken(b, HS_PRAGMA_END) && r;
exit_section_(b, l, m, r, p, null);
return r || p;
}
// (onl CON_ID? onl general_pragma_content? onl PRAGMA_END)+
// general_pragma_content*
private static boolean pragma_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "pragma_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma_1_0(b, l + 1);
while (r) {
while (true) {
int c = current_position_(b);
if (!pragma_1_0(b, l + 1)) break;
if (!general_pragma_content(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "pragma_1", c)) break;
}
exit_section_(b, m, null, r);
return r;
}
// onl CON_ID? onl general_pragma_content? onl PRAGMA_END
private static boolean pragma_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "pragma_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = onl(b, l + 1);
r = r && pragma_1_0_1(b, l + 1);
r = r && onl(b, l + 1);
r = r && pragma_1_0_3(b, l + 1);
r = r && onl(b, l + 1);
r = r && consumeToken(b, HS_PRAGMA_END);
exit_section_(b, m, null, r);
return r;
}
// CON_ID?
private static boolean pragma_1_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "pragma_1_0_1")) return false;
consumeToken(b, HS_CON_ID);
return true;
}
// general_pragma_content?
private static boolean pragma_1_0_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "pragma_1_0_3")) return false;
general_pragma_content(b, l + 1);
return true;
}

4
gen/intellij/haskell/psi/HaskellFileHeaderPragma.java
View File

@ -2,7 +2,6 @@
package intellij.haskell.psi;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
@ -11,7 +10,4 @@ public interface HaskellFileHeaderPragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
@Nullable
HaskellOptionsGhcPragma getOptionsGhcPragma();
}

10
gen/intellij/haskell/psi/HaskellGeneralPragmaContent.java
View File

@ -1,16 +1,6 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public interface HaskellGeneralPragmaContent extends HaskellCompositeElement {
@NotNull
List<HaskellDotDot> getDotDotList();
@NotNull
List<HaskellTextLiteral> getTextLiteralList();
}

7
gen/intellij/haskell/psi/HaskellTypes.java
View File

@ -66,7 +66,6 @@ public interface HaskellTypes {
IElementType HS_NEWCONSTR = new HaskellCompositeElementType("HS_NEWCONSTR");
IElementType HS_NEWCONSTR_FIELDDECL = new HaskellCompositeElementType("HS_NEWCONSTR_FIELDDECL");
IElementType HS_NEWTYPE_DECLARATION = new HaskellCompositeElementType("HS_NEWTYPE_DECLARATION");
IElementType HS_OPTIONS_GHC_PRAGMA = new HaskellCompositeElementType("HS_OPTIONS_GHC_PRAGMA");
IElementType HS_OTHER_PRAGMA = new HaskellCompositeElementType("HS_OTHER_PRAGMA");
IElementType HS_OVERLAP_PRAGMA = new HaskellCompositeElementType("HS_OVERLAP_PRAGMA");
IElementType HS_QUALIFIER = new HaskellCompositeElementType("HS_QUALIFIER");
@ -124,7 +123,6 @@ public interface HaskellTypes {
IElementType HS_DIRECTIVE = new HaskellTokenType("DIRECTIVE");
IElementType HS_DO = new HaskellTokenType("DO");
IElementType HS_DOT = new HaskellTokenType("DOT");
IElementType HS_DOUBLE_QUOTE = new HaskellTokenType("DOUBLE_QUOTE");
IElementType HS_DOUBLE_RIGHT_ARROW = new HaskellTokenType("DOUBLE_RIGHT_ARROW");
IElementType HS_ELSE = new HaskellTokenType("ELSE");
IElementType HS_EQUAL = new HaskellTokenType("EQUAL");
@ -155,8 +153,9 @@ public interface HaskellTypes {
IElementType HS_NOT_TERMINATED_OPTIONS_GHC = new HaskellTokenType("NOT_TERMINATED_OPTIONS_GHC");
IElementType HS_OCTAL = new HaskellTokenType("OCTAL");
IElementType HS_OF = new HaskellTokenType("OF");
IElementType HS_OPTIONS_GHC = new HaskellTokenType("OPTIONS_GHC");
IElementType HS_ONE_PRAGMA = new HaskellTokenType("ONE_PRAGMA");
IElementType HS_PRAGMA_END = new HaskellTokenType("PRAGMA_END");
IElementType HS_PRAGMA_SEP = new HaskellTokenType("PRAGMA_SEP");
IElementType HS_PRAGMA_START = new HaskellTokenType("PRAGMA_START");
IElementType HS_QUASIQUOTE = new HaskellTokenType("QUASIQUOTE");
IElementType HS_QUOTE = new HaskellTokenType("QUOTE");
@ -296,8 +295,6 @@ public interface HaskellTypes {
return new HaskellNewconstrFielddeclImpl(node);
} else if (type == HS_NEWTYPE_DECLARATION) {
return new HaskellNewtypeDeclarationImpl(node);
} else if (type == HS_OPTIONS_GHC_PRAGMA) {
return new HaskellOptionsGhcPragmaImpl(node);
} else if (type == HS_OTHER_PRAGMA) {
return new HaskellOtherPragmaImpl(node);
} else if (type == HS_OVERLAP_PRAGMA) {

4
gen/intellij/haskell/psi/HaskellVisitor.java
View File

@ -239,10 +239,6 @@ public class HaskellVisitor extends PsiElementVisitor {
visitDataConstructorDeclarationElement(o);
}
public void visitOptionsGhcPragma(@NotNull HaskellOptionsGhcPragma o) {
visitCompositeElement(o);
}
public void visitOtherPragma(@NotNull HaskellOtherPragma o) {
visitCompositeElement(o);
}

8
gen/intellij/haskell/psi/impl/HaskellFileHeaderPragmaImpl.java
View File

@ -6,10 +6,8 @@ import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellFileHeaderPragma;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellOptionsGhcPragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
@ -34,10 +32,4 @@ public class HaskellFileHeaderPragmaImpl extends HaskellCompositeElementImpl imp
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
@Override
@Nullable
public HaskellOptionsGhcPragma getOptionsGhcPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellOptionsGhcPragma.class);
}
}

17
gen/intellij/haskell/psi/impl/HaskellGeneralPragmaContentImpl.java
View File

@ -3,15 +3,10 @@ package intellij.haskell.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellDotDot;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellTextLiteral;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellGeneralPragmaContentImpl extends HaskellCompositeElementImpl implements HaskellGeneralPragmaContent {
public HaskellGeneralPragmaContentImpl(ASTNode node) {
@ -27,16 +22,4 @@ public class HaskellGeneralPragmaContentImpl extends HaskellCompositeElementImpl
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellDotDot> getDotDotList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellDotDot.class);
}
@Override
@NotNull
public List<HaskellTextLiteral> getTextLiteralList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellTextLiteral.class);
}
}

25
gen/intellij/haskell/psi/impl/HaskellOptionsGhcPragmaImpl.java
View File

@ -1,25 +0,0 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi.impl;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import intellij.haskell.psi.HaskellOptionsGhcPragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
public class HaskellOptionsGhcPragmaImpl extends HaskellCompositeElementImpl implements HaskellOptionsGhcPragma {
public HaskellOptionsGhcPragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitOptionsGhcPragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
}

30
src/main/scala/intellij/haskell/_HaskellLexer.flex
View File

@ -205,26 +205,34 @@ nhaddock_start = {left_brace}{dash}{white_char}?{vertical_bar}
<OPTIONS_GHC> {
<<EOF>> {
int state = yystate();
yybegin(YYINITIAL);
zzStartRead = optionsGhcStart;
return HS_NOT_TERMINATED_OPTIONS_GHC;
}
{pragma_end} {
int state = yystate();
yybegin(YYINITIAL);
zzStartRead = optionsGhcStart;
return HS_OPTIONS_GHC;
return HS_PRAGMA_END;
}
.|{white_char}|{newline} {}
"," {
return HS_PRAGMA_SEP;
}
{character_literal} { return HS_CHARACTER_LITERAL; }
{string_literal} { return HS_STRING_LITERAL; }
({white_char}|{newline}|{unispace}])+ {
return com.intellij.psi.TokenType.WHITE_SPACE;
}
[\-a-zA-Z0-9_=]+ {
return HS_ONE_PRAGMA;
}
}
{pragma_start} {white_char}* "OPTIONS_GHC" {
{pragma_start} {
yybegin(OPTIONS_GHC);
optionsGhcDepth = 0;
optionsGhcStart = getTokenStart();
return HS_PRAGMA_START;
}
@ -264,6 +272,8 @@ nhaddock_start = {left_brace}{dash}{white_char}?{vertical_bar}
{newline} { return HS_NEWLINE; }
{haddock} { return HS_HADDOCK; }
// TODO: we maybe need to delete these two.
{pragma_start} { return HS_PRAGMA_START; }
{pragma_end} { return HS_PRAGMA_END; }
@ -350,8 +360,6 @@ nhaddock_start = {left_brace}{dash}{white_char}?{vertical_bar}
{directive} { return HS_DIRECTIVE; }
{double_quote} { return HS_DOUBLE_QUOTE; }
{forall} { return HS_FORALL; }
[^] { return com.intellij.psi.TokenType.BAD_CHARACTER; }

993
src/main/scala/intellij/haskell/_HaskellLexer.java
View File

File diff suppressed because it is too large Load Diff

2
src/main/scala/intellij/haskell/editor/HaskellQuoteHandler.scala
View File

@ -19,4 +19,4 @@ package intellij.haskell.editor
import com.intellij.codeInsight.editorActions.SimpleTokenSetQuoteHandler
import intellij.haskell.psi.HaskellTypes._
class HaskellQuoteHandler extends SimpleTokenSetQuoteHandler(HS_STRING_LITERAL, HS_BACKQUOTE, HS_QUOTE, HS_DOUBLE_QUOTE)
class HaskellQuoteHandler extends SimpleTokenSetQuoteHandler(HS_STRING_LITERAL, HS_BACKQUOTE, HS_QUOTE)

12
src/main/scala/intellij/haskell/haskell.bnf
View File

@ -55,19 +55,13 @@
program ::= onl shebang_line? onl file_header onl module_body
shebang_line ::= "#!" general_id+
options_ghc_pragma ::= OPTIONS_GHC
file_header ::= (file_header_pragma onl)*
private pragma ::= PRAGMA_START (onl CON_ID? onl general_pragma_content? onl PRAGMA_END)+ {pin=1}
file_header_pragma ::= pragma NEWLINE | options_ghc_pragma NEWLINE | pragma | options_ghc_pragma
private pragma ::= PRAGMA_START general_pragma_content* PRAGMA_END {pin=1}
file_header_pragma ::= pragma
other_pragma ::= pragma
general_pragma_content ::= (CON_ID | VAR_ID | CONSYM_ID | VARSYM_ID |
LEFT_PAREN | RIGHT_PAREN | FLOAT | UNDERSCORE |
SEMICOLON | LEFT_BRACKET | RIGHT_BRACKET | literal | LEFT_BRACE | RIGHT_BRACE |
COMMA | QUOTE | BACKQUOTE | NEWLINE | DOUBLE_QUOTE | TILDE | DOT | dot_dot | VERTICAL_BAR |
EQUAL | DOUBLE_RIGHT_ARROW | COLON_COLON | RIGHT_ARROW | LEFT_ARROW | BACKSLASH | TYPE |
INSTANCE | MODULE | WHERE | DO | LET | IN | CASE | OF | IF | THEN | ELSE | IMPORT | DIRECTIVE)+
general_pragma_content ::= ONE_PRAGMA | PRAGMA_SEP | CHARACTER_LITERAL | STRING_LITERAL
module_body ::= module_declaration onl body | onl body

16
src/test/scala/intellij/haskell/alex/HaskellParsingTest.scala Normal file
View File

@ -0,0 +1,16 @@
package intellij.haskell.alex
import com.intellij.testFramework.ParsingTestCase
import intellij.haskell.HaskellParserDefinition
class HaskellParsingTest extends ParsingTestCase("", "hs", new HaskellParserDefinition) {
override def getTestDataPath: String = "src/test/testData/parsing-hs"
def testPragma(): Unit = {
doTest(true)
}
def testComplicatedPragma(): Unit = {
doTest(true)
}
}

10
src/test/testData/parsing-hs/ComplicatedPragma.hs Normal file
View File

@ -0,0 +1,10 @@
{-# LANGUAGE TheWorldOverHeaven#-}
{-# OPTIONS_GHC "String" #-}
{-# OPTIONS_GHC " \" Escape \' \n" #-}
{-# OPTIONS_GHC
MULTI
LINE
#-}
{-# LANGUAGE Comma,Separated,Pragmas #-}

70
src/test/testData/parsing-hs/ComplicatedPragma.txt Normal file
View File

@ -0,0 +1,70 @@
Haskell file
HS_FILE_HEADER
HS_FILE_HEADER_PRAGMA
PsiElement(HaskellTokenType.PRAGMA_START)('{-#')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('LANGUAGE')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('TheWorldOverHeaven')
PsiElement(HaskellTokenType.PRAGMA_END)('#-}')
PsiElement(HaskellTokenType.NEWLINE)('\n')
HS_FILE_HEADER_PRAGMA
PsiElement(HaskellTokenType.PRAGMA_START)('{-#')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('OPTIONS_GHC')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.STRING_LITERAL)('"String"')
PsiWhiteSpace(' ')
PsiElement(HaskellTokenType.PRAGMA_END)('#-}')
PsiElement(HaskellTokenType.NEWLINE)('\n')
HS_FILE_HEADER_PRAGMA
PsiElement(HaskellTokenType.PRAGMA_START)('{-#')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('OPTIONS_GHC')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.STRING_LITERAL)('" \" Escape \' \n"')
PsiWhiteSpace(' ')
PsiElement(HaskellTokenType.PRAGMA_END)('#-}')
PsiElement(HaskellTokenType.NEWLINE)('\n')
HS_FILE_HEADER_PRAGMA
PsiElement(HaskellTokenType.PRAGMA_START)('{-#')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('OPTIONS_GHC')
PsiWhiteSpace('\n ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('MULTI')
PsiWhiteSpace('\n ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('LINE')
PsiWhiteSpace('\n ')
PsiElement(HaskellTokenType.PRAGMA_END)('#-}')
PsiElement(HaskellTokenType.NEWLINE)('\n')
PsiElement(HaskellTokenType.NEWLINE)('\n')
HS_FILE_HEADER_PRAGMA
PsiElement(HaskellTokenType.PRAGMA_START)('{-#')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('LANGUAGE')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('Comma')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.PRAGMA_SEP)(',')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('Separated')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.PRAGMA_SEP)(',')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('Pragmas')
PsiWhiteSpace(' ')
PsiElement(HaskellTokenType.PRAGMA_END)('#-}')
HS_MODULE_BODY
HS_IMPORT_DECLARATIONS
<empty list>

3
src/test/testData/parsing-hs/Pragma.hs Normal file
View File

@ -0,0 +1,3 @@
{-# Hey #-}
{-# LANGUAGE OhMyGod #-}
{-# OPTIONS_GHC --omG #-}

34
src/test/testData/parsing-hs/Pragma.txt Normal file
View File

@ -0,0 +1,34 @@
Haskell file
HS_FILE_HEADER
HS_FILE_HEADER_PRAGMA
PsiElement(HaskellTokenType.PRAGMA_START)('{-#')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('Hey')
PsiWhiteSpace(' ')
PsiElement(HaskellTokenType.PRAGMA_END)('#-}')
PsiElement(HaskellTokenType.NEWLINE)('\n')
HS_FILE_HEADER_PRAGMA
PsiElement(HaskellTokenType.PRAGMA_START)('{-#')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('LANGUAGE')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('OhMyGod')
PsiWhiteSpace(' ')
PsiElement(HaskellTokenType.PRAGMA_END)('#-}')
PsiElement(HaskellTokenType.NEWLINE)('\n')
HS_FILE_HEADER_PRAGMA
PsiElement(HaskellTokenType.PRAGMA_START)('{-#')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('OPTIONS_GHC')
PsiWhiteSpace(' ')
HS_GENERAL_PRAGMA_CONTENT
PsiElement(HaskellTokenType.ONE_PRAGMA)('--omG')
PsiWhiteSpace(' ')
PsiElement(HaskellTokenType.PRAGMA_END)('#-}')
HS_MODULE_BODY
HS_IMPORT_DECLARATIONS
<empty list>