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

Removed *_pragma's. Cleanup. WIP.

Browse Source
This commit is contained in:
Rik van der Kleij 2019-02-17 21:41:35 +01:00
parent d3450d9ca1
commit 50a82352e0
69 changed files with 536 additions and 1163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -29,8 +29,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
r = cdecl_data_declaration(b, 0);
} else if (t == HS_CDECLS) {
r = cdecls(b, 0);
} else if (t == HS_CFILES_PRAGMA) {
r = cfiles_pragma(b, 0);
} else if (t == HS_CIDECLS) {
r = cidecls(b, 0);
} else if (t == HS_CLASS_DECLARATION) {
@ -57,8 +55,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
r = constr3(b, 0);
} else if (t == HS_CONSYM) {
r = consym(b, 0);
} else if (t == HS_CTYPE_PRAGMA) {
r = ctype_pragma(b, 0);
} else if (t == HS_DATA_DECLARATION) {
r = data_declaration(b, 0);
} else if (t == HS_DATA_DECLARATION_DERIVING) {
@ -79,8 +75,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
r = fielddecl(b, 0);
} else if (t == HS_FILE_HEADER) {
r = file_header(b, 0);
} else if (t == HS_FILE_HEADER_PRAGMA) {
r = file_header_pragma(b, 0);
} else if (t == HS_FIXITY_DECLARATION) {
r = fixity_declaration(b, 0);
} else if (t == HS_FOREIGN_DECLARATION) {
@ -111,8 +105,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
r = import_qualified_as(b, 0);
} else if (t == HS_IMPORT_SPEC) {
r = import_spec(b, 0);
} else if (t == HS_INLINELIKE_PRAGMA) {
r = inlinelike_pragma(b, 0);
} else if (t == HS_INST) {
r = inst(b, 0);
} else if (t == HS_INSTANCE_DECLARATION) {
@ -123,8 +115,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
r = kind_signature(b, 0);
} else if (t == HS_LIST_TYPE) {
r = list_type(b, 0);
} else if (t == HS_MINIMAL_PRAGMA) {
r = minimal_pragma(b, 0);
} else if (t == HS_MODID) {
r = modid(b, 0);
} else if (t == HS_MODULE_BODY) {
@ -137,10 +127,8 @@ 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_OTHER_PRAGMA) {
r = other_pragma(b, 0);
} else if (t == HS_OVERLAP_INCOHERENT_PRAGMA) {
r = overlap_incoherent_pragma(b, 0);
} else if (t == HS_PRAGMA) {
r = pragma(b, 0);
} else if (t == HS_Q_CON) {
r = q_con(b, 0);
} else if (t == HS_Q_CON_QUALIFIER) {
@ -163,8 +151,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
r = qualifier(b, 0);
} else if (t == HS_RESERVED_ID) {
r = reserved_id(b, 0);
} else if (t == HS_SCC_PRAGMA) {
r = scc_pragma(b, 0);
} else if (t == HS_SCONTEXT) {
r = scontext(b, 0);
} else if (t == HS_SHEBANG_LINE) {
@ -173,10 +159,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
r = simpleclass(b, 0);
} else if (t == HS_SIMPLETYPE) {
r = simpletype(b, 0);
} else if (t == HS_SOURCE_PRAGMA) {
r = source_pragma(b, 0);
} else if (t == HS_SPECIALIZE_PRAGMA) {
r = specialize_pragma(b, 0);
} else if (t == HS_TEXT_LITERAL) {
r = text_literal(b, 0);
} else if (t == HS_TOP_DECLARATION) {
@ -201,8 +183,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
r = type_instance_declaration(b, 0);
} else if (t == HS_TYPE_SIGNATURE) {
r = type_signature(b, 0);
} else if (t == HS_UNPACK_NOUNPACK_PRAGMA) {
r = unpack_nounpack_pragma(b, 0);
} else if (t == HS_VAR) {
r = var(b, 0);
} else if (t == HS_VAR_CON) {
@ -877,7 +857,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// DATA (onls ctype_pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype (onls LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* (onls COLON_COLON ttype)? q_name*
// DATA (onls pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype (onls LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* (onls COLON_COLON ttype)? q_name*
public static boolean cdecl_data_declaration(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "cdecl_data_declaration")) return false;
if (!nextTokenIs(b, HS_DATA)) return false;
@ -896,20 +876,20 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// (onls ctype_pragma)?
// (onls pragma)?
private static boolean cdecl_data_declaration_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "cdecl_data_declaration_1")) return false;
cdecl_data_declaration_1_0(b, l + 1);
return true;
}
// onls ctype_pragma
// onls pragma
private static boolean cdecl_data_declaration_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "cdecl_data_declaration_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = onls(b, l + 1);
r = r && ctype_pragma(b, l + 1);
r = r && pragma(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@ -1030,30 +1010,16 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// pragma
public static boolean cfiles_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "cfiles_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_CFILES_PRAGMA, r);
return r;
}
/* ********************************************************** */
// inlinelike_pragma | specialize_pragma | instance_declaration | default_declaration |
// newtype_declaration | data_declaration | minimal_pragma | type_declaration | type_family_declaration | line_expression
// pragma | instance_declaration | default_declaration |
// newtype_declaration | data_declaration | type_declaration | type_family_declaration | line_expression
static boolean cidecl(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "cidecl")) return false;
boolean r;
r = inlinelike_pragma(b, l + 1);
if (!r) r = specialize_pragma(b, l + 1);
r = pragma(b, l + 1);
if (!r) r = instance_declaration(b, l + 1);
if (!r) r = default_declaration(b, l + 1);
if (!r) r = newtype_declaration(b, l + 1);
if (!r) r = data_declaration(b, l + 1);
if (!r) r = minimal_pragma(b, l + 1);
if (!r) r = type_declaration(b, l + 1);
if (!r) r = type_family_declaration(b, l + 1);
if (!r) r = line_expression(b, l + 1);
@ -1592,7 +1558,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// unpack_nounpack_pragma? (onls q_name)? (onls unpack_nounpack_pragma)? onls LEFT_BRACE onl fielddecl? ((onl COMMA)? onl fielddecl)* onl RIGHT_BRACE
// pragma? (onls q_name)? (onls pragma)? onls LEFT_BRACE onl fielddecl? ((onl COMMA)? onl fielddecl)* onl RIGHT_BRACE
public static boolean constr1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr1")) return false;
boolean r;
@ -1611,10 +1577,10 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// unpack_nounpack_pragma?
// pragma?
private static boolean constr1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr1_0")) return false;
unpack_nounpack_pragma(b, l + 1);
pragma(b, l + 1);
return true;
}
@ -1636,20 +1602,20 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// (onls unpack_nounpack_pragma)?
// (onls pragma)?
private static boolean constr1_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr1_2")) return false;
constr1_2_0(b, l + 1);
return true;
}
// onls unpack_nounpack_pragma
// onls pragma
private static boolean constr1_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr1_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = onls(b, l + 1);
r = r && unpack_nounpack_pragma(b, l + 1);
r = r && pragma(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@ -1703,7 +1669,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// unpack_nounpack_pragma? onls (ttype | q_name | LEFT_PAREN q_name* RIGHT_PAREN | LEFT_BRACKET q_name* RIGHT_BRACKET) (onls unpack_nounpack_pragma onls)? ((onls unpack_nounpack_pragma)? onls ttype (onls unpack_nounpack_pragma)?)*
// pragma? onls (ttype | q_name | LEFT_PAREN q_name* RIGHT_PAREN | LEFT_BRACKET q_name* RIGHT_BRACKET) (onls pragma onls)? ((onls pragma)? onls ttype (onls pragma)?)*
public static boolean constr2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2")) return false;
boolean r;
@ -1717,10 +1683,10 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// unpack_nounpack_pragma?
// pragma?
private static boolean constr2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2_0")) return false;
unpack_nounpack_pragma(b, l + 1);
pragma(b, l + 1);
return true;
}
@ -1783,26 +1749,26 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return true;
}
// (onls unpack_nounpack_pragma onls)?
// (onls pragma onls)?
private static boolean constr2_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2_3")) return false;
constr2_3_0(b, l + 1);
return true;
}
// onls unpack_nounpack_pragma onls
// onls pragma onls
private static boolean constr2_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = onls(b, l + 1);
r = r && unpack_nounpack_pragma(b, l + 1);
r = r && pragma(b, l + 1);
r = r && onls(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// ((onls unpack_nounpack_pragma)? onls ttype (onls unpack_nounpack_pragma)?)*
// ((onls pragma)? onls ttype (onls pragma)?)*
private static boolean constr2_4(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2_4")) return false;
while (true) {
@ -1813,7 +1779,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return true;
}
// (onls unpack_nounpack_pragma)? onls ttype (onls unpack_nounpack_pragma)?
// (onls pragma)? onls ttype (onls pragma)?
private static boolean constr2_4_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2_4_0")) return false;
boolean r;
@ -1826,44 +1792,44 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// (onls unpack_nounpack_pragma)?
// (onls pragma)?
private static boolean constr2_4_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2_4_0_0")) return false;
constr2_4_0_0_0(b, l + 1);
return true;
}
// onls unpack_nounpack_pragma
// onls pragma
private static boolean constr2_4_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2_4_0_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = onls(b, l + 1);
r = r && unpack_nounpack_pragma(b, l + 1);
r = r && pragma(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (onls unpack_nounpack_pragma)?
// (onls pragma)?
private static boolean constr2_4_0_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2_4_0_3")) return false;
constr2_4_0_3_0(b, l + 1);
return true;
}
// onls unpack_nounpack_pragma
// onls pragma
private static boolean constr2_4_0_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr2_4_0_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = onls(b, l + 1);
r = r && unpack_nounpack_pragma(b, l + 1);
r = r && pragma(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// (onls unpack_nounpack_pragma? onls ttype)+
// (onls pragma? onls ttype)+
public static boolean constr3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr3")) return false;
boolean r;
@ -1878,7 +1844,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// onls unpack_nounpack_pragma? onls ttype
// onls pragma? onls ttype
private static boolean constr3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr3_0")) return false;
boolean r;
@ -1891,10 +1857,10 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// unpack_nounpack_pragma?
// pragma?
private static boolean constr3_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "constr3_0_1")) return false;
unpack_nounpack_pragma(b, l + 1);
pragma(b, l + 1);
return true;
}
@ -1947,21 +1913,9 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// pragma
public static boolean ctype_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ctype_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_CTYPE_PRAGMA, r);
return r;
}
/* ********************************************************** */
// DATA (onls ctype_pragma)? onls INSTANCE? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* onls (EQUAL | WHERE)?
// DATA (onls pragma)? onls INSTANCE? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* onls (EQUAL | WHERE)?
// onls (type_signature (nls type_signature)* | constrs) (onls data_declaration_deriving)? |
// DATA (onls ctype_pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* (onls data_declaration_deriving)?
// DATA (onls pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* (onls data_declaration_deriving)?
public static boolean data_declaration(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "data_declaration")) return false;
if (!nextTokenIs(b, HS_DATA)) return false;
@ -1973,7 +1927,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// DATA (onls ctype_pragma)? onls INSTANCE? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* onls (EQUAL | WHERE)?
// DATA (onls pragma)? onls INSTANCE? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* onls (EQUAL | WHERE)?
// onls (type_signature (nls type_signature)* | constrs) (onls data_declaration_deriving)?
private static boolean data_declaration_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "data_declaration_0")) return false;
@ -2002,20 +1956,20 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// (onls ctype_pragma)?
// (onls pragma)?
private static boolean data_declaration_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "data_declaration_0_1")) return false;
data_declaration_0_1_0(b, l + 1);
return true;
}
// onls ctype_pragma
// onls pragma
private static boolean data_declaration_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "data_declaration_0_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = onls(b, l + 1);
r = r && ctype_pragma(b, l + 1);
r = r && pragma(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@ -2178,7 +2132,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// DATA (onls ctype_pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* (onls data_declaration_deriving)?
// DATA (onls pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* (onls data_declaration_deriving)?
private static boolean data_declaration_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "data_declaration_1")) return false;
boolean r;
@ -2200,20 +2154,20 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// (onls ctype_pragma)?
// (onls pragma)?
private static boolean data_declaration_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "data_declaration_1_1")) return false;
data_declaration_1_1_0(b, l + 1);
return true;
}
// onls ctype_pragma
// onls pragma
private static boolean data_declaration_1_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "data_declaration_1_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = onls(b, l + 1);
r = r && ctype_pragma(b, l + 1);
r = r && pragma(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@ -2812,7 +2766,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// q_names (onl COLON_COLON unpack_nounpack_pragma? (onls ("forall" | FORALL) (onls q_name)+)? (onls scontext onls DOUBLE_RIGHT_ARROW)? unpack_nounpack_pragma? onls ttype)?
// q_names (onl COLON_COLON pragma? (onls ("forall" | FORALL) (onls q_name)+)? (onls scontext onls DOUBLE_RIGHT_ARROW)? pragma? onls ttype)?
public static boolean fielddecl(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "fielddecl")) return false;
boolean r;
@ -2823,14 +2777,14 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// (onl COLON_COLON unpack_nounpack_pragma? (onls ("forall" | FORALL) (onls q_name)+)? (onls scontext onls DOUBLE_RIGHT_ARROW)? unpack_nounpack_pragma? onls ttype)?
// (onl COLON_COLON pragma? (onls ("forall" | FORALL) (onls q_name)+)? (onls scontext onls DOUBLE_RIGHT_ARROW)? pragma? onls ttype)?
private static boolean fielddecl_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "fielddecl_1")) return false;
fielddecl_1_0(b, l + 1);
return true;
}
// onl COLON_COLON unpack_nounpack_pragma? (onls ("forall" | FORALL) (onls q_name)+)? (onls scontext onls DOUBLE_RIGHT_ARROW)? unpack_nounpack_pragma? onls ttype
// onl COLON_COLON pragma? (onls ("forall" | FORALL) (onls q_name)+)? (onls scontext onls DOUBLE_RIGHT_ARROW)? pragma? onls ttype
private static boolean fielddecl_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "fielddecl_1_0")) return false;
boolean r;
@ -2847,10 +2801,10 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// unpack_nounpack_pragma?
// pragma?
private static boolean fielddecl_1_0_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "fielddecl_1_0_2")) return false;
unpack_nounpack_pragma(b, l + 1);
pragma(b, l + 1);
return true;
}
@ -2930,15 +2884,15 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// unpack_nounpack_pragma?
// pragma?
private static boolean fielddecl_1_0_5(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "fielddecl_1_0_5")) return false;
unpack_nounpack_pragma(b, l + 1);
pragma(b, l + 1);
return true;
}
/* ********************************************************** */
// (file_header_pragma onl)*
// (pragma onl)*
public static boolean file_header(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "file_header")) return false;
Marker m = enter_section_(b, l, _NONE_, HS_FILE_HEADER, "<file header>");
@ -2951,29 +2905,17 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return true;
}
// file_header_pragma onl
// pragma onl
private static boolean file_header_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "file_header_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = file_header_pragma(b, l + 1);
r = pragma(b, l + 1);
r = r && onl(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// pragma
public static boolean file_header_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "file_header_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_FILE_HEADER_PRAGMA, r);
return r;
}
/* ********************************************************** */
// INFIXL | INFIXR | INFIX
static boolean fixity(PsiBuilder b, int l) {
@ -3032,7 +2974,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
// QUASIQUOTE | q_name | symbol_reserved_op | reserved_id | LEFT_PAREN | RIGHT_PAREN | FLOAT |
// SEMICOLON | LEFT_BRACKET | RIGHT_BRACKET | literal | LEFT_BRACE | RIGHT_BRACE |
// COMMA | QUOTE | BACKQUOTE | fixity |
// inlinelike_pragma | DIRECTIVE | scc_pragma
// pragma | DIRECTIVE
static boolean general_id(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "general_id")) return false;
boolean r;
@ -3053,9 +2995,8 @@ public class HaskellParser implements PsiParser, LightPsiParser {
if (!r) r = consumeToken(b, HS_QUOTE);
if (!r) r = consumeToken(b, HS_BACKQUOTE);
if (!r) r = fixity(b, l + 1);
if (!r) r = inlinelike_pragma(b, l + 1);
if (!r) r = pragma(b, l + 1);
if (!r) r = consumeToken(b, HS_DIRECTIVE);
if (!r) r = scc_pragma(b, l + 1);
return r;
}
@ -3148,7 +3089,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// IMPORT (onls source_pragma)? (onls import_qualified)? (onls import_package_name)? onls modid onls import_qualified_as? onls import_spec?
// IMPORT (onls pragma)? (onls import_qualified)? (onls import_package_name)? onls modid onls import_qualified_as? onls import_spec?
public static boolean import_declaration(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "import_declaration")) return false;
if (!nextTokenIs(b, HS_IMPORT)) return false;
@ -3169,20 +3110,20 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r || p;
}
// (onls source_pragma)?
// (onls pragma)?
private static boolean import_declaration_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "import_declaration_1")) return false;
import_declaration_1_0(b, l + 1);
return true;
}
// onls source_pragma
// onls pragma
private static boolean import_declaration_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "import_declaration_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = onls(b, l + 1);
r = r && source_pragma(b, l + 1);
r = r && pragma(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@ -3238,7 +3179,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// ((import_declaration | cfiles_pragma | DIRECTIVE) onl)*
// ((import_declaration | pragma | DIRECTIVE) onl)*
public static boolean import_declarations(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "import_declarations")) return false;
Marker m = enter_section_(b, l, _NONE_, HS_IMPORT_DECLARATIONS, "<import declarations>");
@ -3251,7 +3192,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return true;
}
// (import_declaration | cfiles_pragma | DIRECTIVE) onl
// (import_declaration | pragma | DIRECTIVE) onl
private static boolean import_declarations_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "import_declarations_0")) return false;
boolean r;
@ -3262,12 +3203,12 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// import_declaration | cfiles_pragma | DIRECTIVE
// import_declaration | pragma | DIRECTIVE
private static boolean import_declarations_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "import_declarations_0_0")) return false;
boolean r;
r = import_declaration(b, l + 1);
if (!r) r = cfiles_pragma(b, l + 1);
if (!r) r = pragma(b, l + 1);
if (!r) r = consumeToken(b, HS_DIRECTIVE);
return r;
}
@ -3559,18 +3500,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// pragma
public static boolean inlinelike_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "inlinelike_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_INLINELIKE_PRAGMA, r);
return r;
}
/* ********************************************************** */
// gtycon+ instvar* (LEFT_PAREN onls gtycon (instvar)* onls RIGHT_PAREN)* instvar* |
// (LEFT_PAREN onls instvar (onls COMMA onls instvar)+ onls RIGHT_PAREN)+ instvar* |
@ -4018,7 +3947,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// INSTANCE onls ("OVERLAPPABLE_" | "OVERLAPPING_" | overlap_incoherent_pragma)? onls (var_con+ DOT)? onls (scontext onls DOUBLE_RIGHT_ARROW)? onls
// INSTANCE onls ("OVERLAPPABLE_" | "OVERLAPPING_" | pragma)? onls (var_con+ DOT)? onls (scontext onls DOUBLE_RIGHT_ARROW)? onls
// (type_equality | q_name onls inst (onls WHERE (onls cidecls)?)?)
public static boolean instance_declaration(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "instance_declaration")) return false;
@ -4038,21 +3967,21 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
// ("OVERLAPPABLE_" | "OVERLAPPING_" | overlap_incoherent_pragma)?
// ("OVERLAPPABLE_" | "OVERLAPPING_" | pragma)?
private static boolean instance_declaration_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "instance_declaration_2")) return false;
instance_declaration_2_0(b, l + 1);
return true;
}
// "OVERLAPPABLE_" | "OVERLAPPING_" | overlap_incoherent_pragma
// "OVERLAPPABLE_" | "OVERLAPPING_" | pragma
private static boolean instance_declaration_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "instance_declaration_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, "OVERLAPPABLE_");
if (!r) r = consumeToken(b, "OVERLAPPING_");
if (!r) r = overlap_incoherent_pragma(b, l + 1);
if (!r) r = pragma(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
@ -4324,18 +4253,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// pragma
public static boolean minimal_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "minimal_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_MINIMAL_PRAGMA, r);
return r;
}
/* ********************************************************** */
// (conid DOT)* conid
public static boolean modid(PsiBuilder b, int l) {
@ -4504,7 +4421,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
}
/* ********************************************************** */
// NEWTYPE onls INSTANCE? onls ctype_pragma? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls EQUAL onls newconstr (onls DERIVING onls ttype)?
// NEWTYPE onls INSTANCE? onls pragma? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls EQUAL onls newconstr (onls DERIVING onls ttype)?
public static boolean newtype_declaration(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "newtype_declaration")) return false;
if (!nextTokenIs(b, HS_NEWTYPE)) return false;
@ -4535,10 +4452,10 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return true;
}
// ctype_pragma?
// pragma?
private static boolean newtype_declaration_4(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "newtype_declaration_4")) return false;
ctype_pragma(b, l + 1);
pragma(b, l + 1);
return true;
}
@ -4742,37 +4659,13 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// pragma
public static boolean other_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "other_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_OTHER_PRAGMA, r);
return r;
}
/* ********************************************************** */
// pragma
public static boolean overlap_incoherent_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "overlap_incoherent_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_OVERLAP_INCOHERENT_PRAGMA, r);
return r;
}
/* ********************************************************** */
// PRAGMA_START general_pragma_content* PRAGMA_END
static boolean pragma(PsiBuilder b, int l) {
public static boolean pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_);
Marker m = enter_section_(b, l, _NONE_, HS_PRAGMA, null);
r = consumeToken(b, HS_PRAGMA_START);
p = r; // pin = 1
r = r && report_error_(b, pragma_1(b, l + 1));
@ -5203,18 +5096,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// pragma
public static boolean scc_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "scc_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_SCC_PRAGMA, r);
return r;
}
/* ********************************************************** */
// simpleclass | simpleclass onls LEFT_PAREN onls simpleclass (onls COMMA onls simpleclass)* onls RIGHT_PAREN
public static boolean scontext(PsiBuilder b, int l) {
@ -5549,30 +5430,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return true;
}
/* ********************************************************** */
// pragma
public static boolean source_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "source_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_SOURCE_PRAGMA, r);
return r;
}
/* ********************************************************** */
// pragma
public static boolean specialize_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "specialize_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_SPECIALIZE_PRAGMA, r);
return r;
}
/* ********************************************************** */
// dot_dot | COLON_COLON | EQUAL | BACKSLASH | VERTICAL_BAR | LEFT_ARROW | RIGHT_ARROW | AT | TILDE | DOUBLE_RIGHT_ARROW
static boolean symbol_reserved_op(PsiBuilder b, int l) {
@ -5606,7 +5463,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
/* ********************************************************** */
// type_declaration | data_declaration | newtype_declaration | class_declaration | instance_declaration | default_declaration |
// foreign_declaration | type_family_declaration | deriving_declaration | type_instance_declaration | type_signature |
// other_pragma | fixity_declaration | expression | DIRECTIVE
// pragma | fixity_declaration | expression | DIRECTIVE
public static boolean top_declaration(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "top_declaration")) return false;
boolean r;
@ -5622,7 +5479,7 @@ public class HaskellParser implements PsiParser, LightPsiParser {
if (!r) r = deriving_declaration(b, l + 1);
if (!r) r = type_instance_declaration(b, l + 1);
if (!r) r = type_signature(b, l + 1);
if (!r) r = other_pragma(b, l + 1);
if (!r) r = pragma(b, l + 1);
if (!r) r = fixity_declaration(b, l + 1);
if (!r) r = expression(b, l + 1);
if (!r) r = consumeToken(b, HS_DIRECTIVE);
@ -6462,18 +6319,6 @@ public class HaskellParser implements PsiParser, LightPsiParser {
return r;
}
/* ********************************************************** */
// pragma
public static boolean unpack_nounpack_pragma(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "unpack_nounpack_pragma")) return false;
if (!nextTokenIs(b, HS_PRAGMA_START)) return false;
boolean r;
Marker m = enter_section_(b);
r = pragma(b, l + 1);
exit_section_(b, m, HS_UNPACK_NOUNPACK_PRAGMA, r);
return r;
}
/* ********************************************************** */
// varid | LEFT_PAREN varsym RIGHT_PAREN
public static boolean var(PsiBuilder b, int l) {

6
gen/intellij/haskell/psi/HaskellCdeclDataDeclaration.java
View File

@ -8,12 +8,12 @@ import java.util.List;
public interface HaskellCdeclDataDeclaration extends HaskellCompositeElement {
@Nullable
HaskellCtypePragma getCtypePragma();
@NotNull
List<HaskellKindSignature> getKindSignatureList();
@Nullable
HaskellPragma getPragma();
@NotNull
List<HaskellQName> getQNameList();

13
gen/intellij/haskell/psi/HaskellCdecls.java
View File

@ -19,17 +19,14 @@ public interface HaskellCdecls extends HaskellCompositeElement {
@NotNull
List<HaskellDotDot> getDotDotList();
@NotNull
List<HaskellInlinelikePragma> getInlinelikePragmaList();
@NotNull
List<HaskellInstanceDeclaration> getInstanceDeclarationList();
@NotNull
List<HaskellMinimalPragma> getMinimalPragmaList();
List<HaskellNewtypeDeclaration> getNewtypeDeclarationList();
@NotNull
List<HaskellNewtypeDeclaration> getNewtypeDeclarationList();
List<HaskellPragma> getPragmaList();
@NotNull
List<HaskellQName> getQNameList();
@ -37,12 +34,6 @@ public interface HaskellCdecls extends HaskellCompositeElement {
@NotNull
List<HaskellReservedId> getReservedIdList();
@NotNull
List<HaskellSccPragma> getSccPragmaList();
@NotNull
List<HaskellSpecializePragma> getSpecializePragmaList();
@NotNull
List<HaskellTextLiteral> getTextLiteralList();

13
gen/intellij/haskell/psi/HaskellCfilesPragma.java
View File

@ -1,13 +0,0 @@
// 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 HaskellCfilesPragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

11
gen/intellij/haskell/psi/HaskellCideclExpression.java
View File

@ -1,11 +0,0 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi;
import org.jetbrains.annotations.NotNull;
public interface HaskellCideclExpression extends HaskellCompositeElement {
@NotNull
HaskellExpression getExpression();
}

13
gen/intellij/haskell/psi/HaskellCidecls.java
View File

@ -16,17 +16,14 @@ public interface HaskellCidecls extends HaskellCompositeElement {
@NotNull
List<HaskellDotDot> getDotDotList();
@NotNull
List<HaskellInlinelikePragma> getInlinelikePragmaList();
@NotNull
List<HaskellInstanceDeclaration> getInstanceDeclarationList();
@NotNull
List<HaskellMinimalPragma> getMinimalPragmaList();
List<HaskellNewtypeDeclaration> getNewtypeDeclarationList();
@NotNull
List<HaskellNewtypeDeclaration> getNewtypeDeclarationList();
List<HaskellPragma> getPragmaList();
@NotNull
List<HaskellQName> getQNameList();
@ -34,12 +31,6 @@ public interface HaskellCidecls extends HaskellCompositeElement {
@NotNull
List<HaskellReservedId> getReservedIdList();
@NotNull
List<HaskellSccPragma> getSccPragmaList();
@NotNull
List<HaskellSpecializePragma> getSpecializePragmaList();
@NotNull
List<HaskellTextLiteral> getTextLiteralList();

6
gen/intellij/haskell/psi/HaskellConstr1.java
View File

@ -11,10 +11,10 @@ public interface HaskellConstr1 extends HaskellCompositeElement {
@NotNull
List<HaskellFielddecl> getFielddeclList();
@NotNull
List<HaskellPragma> getPragmaList();
@Nullable
HaskellQName getQName();
@NotNull
List<HaskellUnpackNounpackPragma> getUnpackNounpackPragmaList();
}

6
gen/intellij/haskell/psi/HaskellConstr2.java
View File

@ -8,13 +8,13 @@ import java.util.List;
public interface HaskellConstr2 extends HaskellCompositeElement {
@NotNull
List<HaskellPragma> getPragmaList();
@Nullable
HaskellQName getQName();
@NotNull
List<HaskellTtype> getTtypeList();
@NotNull
List<HaskellUnpackNounpackPragma> getUnpackNounpackPragmaList();
}

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

@ -8,9 +8,9 @@ import java.util.List;
public interface HaskellConstr3 extends HaskellCompositeElement {
@NotNull
List<HaskellTtype> getTtypeList();
List<HaskellPragma> getPragmaList();
@NotNull
List<HaskellUnpackNounpackPragma> getUnpackNounpackPragmaList();
List<HaskellTtype> getTtypeList();
}

13
gen/intellij/haskell/psi/HaskellCtypePragma.java
View File

@ -1,13 +0,0 @@
// 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 HaskellCtypePragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

6
gen/intellij/haskell/psi/HaskellDataDeclaration.java
View File

@ -23,15 +23,15 @@ public interface HaskellDataDeclaration extends HaskellDataConstructorDeclaratio
@NotNull
List<HaskellConstr3> getConstr3List();
@Nullable
HaskellCtypePragma getCtypePragma();
@Nullable
HaskellDataDeclarationDeriving getDataDeclarationDeriving();
@NotNull
List<HaskellKindSignature> getKindSignatureList();
@Nullable
HaskellPragma getPragma();
@NotNull
List<HaskellQName> getQNameList();

5
gen/intellij/haskell/psi/HaskellExpression.java
View File

@ -11,7 +11,7 @@ public interface HaskellExpression extends HaskellExpressionElement {
List<HaskellDotDot> getDotDotList();
@NotNull
List<HaskellInlinelikePragma> getInlinelikePragmaList();
List<HaskellPragma> getPragmaList();
@NotNull
List<HaskellQName> getQNameList();
@ -19,9 +19,6 @@ public interface HaskellExpression extends HaskellExpressionElement {
@NotNull
List<HaskellReservedId> getReservedIdList();
@NotNull
List<HaskellSccPragma> getSccPragmaList();
@NotNull
List<HaskellTextLiteral> getTextLiteralList();

6
gen/intellij/haskell/psi/HaskellFielddecl.java
View File

@ -8,6 +8,9 @@ import java.util.List;
public interface HaskellFielddecl extends HaskellCompositeElement {
@NotNull
List<HaskellPragma> getPragmaList();
@NotNull
List<HaskellQName> getQNameList();
@ -20,7 +23,4 @@ public interface HaskellFielddecl extends HaskellCompositeElement {
@Nullable
HaskellTtype getTtype();
@NotNull
List<HaskellUnpackNounpackPragma> getUnpackNounpackPragmaList();
}

2
gen/intellij/haskell/psi/HaskellFileHeader.java
View File

@ -8,6 +8,6 @@ import java.util.List;
public interface HaskellFileHeader extends HaskellCompositeElement {
@NotNull
List<HaskellFileHeaderPragma> getFileHeaderPragmaList();
List<HaskellPragma> getPragmaList();
}

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

@ -1,13 +0,0 @@
// 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 HaskellFileHeaderPragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

30
gen/intellij/haskell/psi/HaskellImportDeclaration.java
View File

@ -1,31 +1,29 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.Nullable;
import scala.Option;
public interface HaskellImportDeclaration extends HaskellCompositeElement {
@Nullable
HaskellImportPackageName getImportPackageName();
@Nullable
HaskellImportPackageName getImportPackageName();
@Nullable
HaskellImportQualified getImportQualified();
@Nullable
HaskellImportQualified getImportQualified();
@Nullable
HaskellImportQualifiedAs getImportQualifiedAs();
@Nullable
HaskellImportQualifiedAs getImportQualifiedAs();
@Nullable
HaskellImportSpec getImportSpec();
@Nullable
HaskellImportSpec getImportSpec();
@Nullable
HaskellModid getModid();
@Nullable
HaskellModid getModid();
@Nullable
HaskellSourcePragma getSourcePragma();
@Nullable
HaskellPragma getPragma();
Option<String> getModuleName();
Option<String> getModuleName();
}

12
gen/intellij/haskell/psi/HaskellImportDeclarations.java
View File

@ -1,16 +1,16 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi;
import org.jetbrains.annotations.NotNull;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.psi.PsiElement;
public interface HaskellImportDeclarations extends HaskellCompositeElement {
@NotNull
List<HaskellCfilesPragma> getCfilesPragmaList();
@NotNull
List<HaskellImportDeclaration> getImportDeclarationList();
@NotNull
List<HaskellImportDeclaration> getImportDeclarationList();
@NotNull
List<HaskellPragma> getPragmaList();
}

13
gen/intellij/haskell/psi/HaskellInlinelikePragma.java
View File

@ -1,13 +0,0 @@
// 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 HaskellInlinelikePragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

2
gen/intellij/haskell/psi/HaskellInstanceDeclaration.java
View File

@ -18,7 +18,7 @@ public interface HaskellInstanceDeclaration extends HaskellDeclarationElement {
HaskellInst getInst();
@Nullable
HaskellOverlapIncoherentPragma getOverlapIncoherentPragma();
HaskellPragma getPragma();
@Nullable
HaskellQName getQName();

13
gen/intellij/haskell/psi/HaskellMinimalPragma.java
View File

@ -1,13 +0,0 @@
// 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 HaskellMinimalPragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

8
gen/intellij/haskell/psi/HaskellModuleDeclaration.java
View File

@ -7,19 +7,17 @@ import org.jetbrains.annotations.Nullable;
import scala.Option;
import scala.collection.Seq;
import java.util.List;
public interface HaskellModuleDeclaration extends HaskellDeclarationElement {
@Nullable
HaskellExports getExports();
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
@NotNull
HaskellModid getModid();
@Nullable
HaskellPragma getPragma();
String getName();
ItemPresentation getPresentation();

35
gen/intellij/haskell/psi/HaskellNewtypeDeclaration.java
View File

@ -1,38 +1,37 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.psi.PsiElement;
import com.intellij.navigation.ItemPresentation;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import scala.Option;
import scala.collection.Seq;
public interface HaskellNewtypeDeclaration extends HaskellDataConstructorDeclarationElement {
@Nullable
HaskellCcontext getCcontext();
@Nullable
HaskellCcontext getCcontext();
@Nullable
HaskellCtypePragma getCtypePragma();
@NotNull
HaskellNewconstr getNewconstr();
@NotNull
HaskellNewconstr getNewconstr();
@Nullable
HaskellPragma getPragma();
@NotNull
HaskellSimpletype getSimpletype();
@NotNull
HaskellSimpletype getSimpletype();
@Nullable
HaskellTtype getTtype();
@Nullable
HaskellTtype getTtype();
String getName();
String getName();
ItemPresentation getPresentation();
ItemPresentation getPresentation();
Seq<HaskellNamedElement> getIdentifierElements();
Seq<HaskellNamedElement> getIdentifierElements();
Option<String> getModuleName();
Option<String> getModuleName();
HaskellNamedElement getDataTypeConstructor();
HaskellNamedElement getDataTypeConstructor();
}

6
gen/intellij/haskell/psi/HaskellOptionsGhcPragma.java
View File

@ -1,6 +0,0 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi;
public interface HaskellOptionsGhcPragma extends HaskellCompositeElement {
}

13
gen/intellij/haskell/psi/HaskellOtherPragma.java
View File

@ -1,13 +0,0 @@
// 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 HaskellOtherPragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

13
gen/intellij/haskell/psi/HaskellOverlapIncoherentPragma.java
View File

@ -1,13 +0,0 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.psi.PsiElement;
public interface HaskellOverlapIncoherentPragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

2
gen/intellij/haskell/psi/HaskellSccPragma.java → gen/intellij/haskell/psi/HaskellPragma.java
View File

@ -5,7 +5,7 @@ import org.jetbrains.annotations.NotNull;
import java.util.List;
public interface HaskellSccPragma extends HaskellCompositeElement {
public interface HaskellPragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();

5
gen/intellij/haskell/psi/HaskellShebangLine.java
View File

@ -11,7 +11,7 @@ public interface HaskellShebangLine extends HaskellCompositeElement {
List<HaskellDotDot> getDotDotList();
@NotNull
List<HaskellInlinelikePragma> getInlinelikePragmaList();
List<HaskellPragma> getPragmaList();
@NotNull
List<HaskellQName> getQNameList();
@ -19,9 +19,6 @@ public interface HaskellShebangLine extends HaskellCompositeElement {
@NotNull
List<HaskellReservedId> getReservedIdList();
@NotNull
List<HaskellSccPragma> getSccPragmaList();
@NotNull
List<HaskellTextLiteral> getTextLiteralList();

13
gen/intellij/haskell/psi/HaskellSourcePragma.java
View File

@ -1,13 +0,0 @@
// 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 HaskellSourcePragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

13
gen/intellij/haskell/psi/HaskellSpecializePragma.java
View File

@ -1,13 +0,0 @@
// 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 HaskellSpecializePragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

6
gen/intellij/haskell/psi/HaskellStringLiteral.java
View File

@ -1,6 +0,0 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi;
public interface HaskellStringLiteral extends HaskellStringLiteralElement {
}

2
gen/intellij/haskell/psi/HaskellTopDeclaration.java
View File

@ -33,7 +33,7 @@ public interface HaskellTopDeclaration extends HaskellCompositeElement {
HaskellNewtypeDeclaration getNewtypeDeclaration();
@Nullable
HaskellOtherPragma getOtherPragma();
HaskellPragma getPragma();
@Nullable
HaskellTypeDeclaration getTypeDeclaration();

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

@ -1,15 +1,16 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.psi.tree.IElementType;
import intellij.haskell.psi.impl.HaskellElementTypeFactory;
import intellij.haskell.psi.impl.*;
public interface HaskellTypes {
IElementType HS_CCONTEXT = new HaskellCompositeElementType("HS_CCONTEXT");
IElementType HS_CDECLS = new HaskellCompositeElementType("HS_CDECLS");
IElementType HS_CDECL_DATA_DECLARATION = new HaskellCompositeElementType("HS_CDECL_DATA_DECLARATION");
IElementType HS_CFILES_PRAGMA = new HaskellCompositeElementType("HS_CFILES_PRAGMA");
IElementType HS_CIDECLS = new HaskellCompositeElementType("HS_CIDECLS");
IElementType HS_CLASS_DECLARATION = new HaskellCompositeElementType("HS_CLASS_DECLARATION");
IElementType HS_CLAZZ = new HaskellCompositeElementType("HS_CLAZZ");
@ -23,7 +24,6 @@ public interface HaskellTypes {
IElementType HS_CONSTR_2 = new HaskellCompositeElementType("HS_CONSTR_2");
IElementType HS_CONSTR_3 = new HaskellCompositeElementType("HS_CONSTR_3");
IElementType HS_CONSYM = HaskellElementTypeFactory.factory("HS_CONSYM");
IElementType HS_CTYPE_PRAGMA = new HaskellCompositeElementType("HS_CTYPE_PRAGMA");
IElementType HS_DATA_DECLARATION = new HaskellCompositeElementType("HS_DATA_DECLARATION");
IElementType HS_DATA_DECLARATION_DERIVING = new HaskellCompositeElementType("HS_DATA_DECLARATION_DERIVING");
IElementType HS_DEFAULT_DECLARATION = new HaskellCompositeElementType("HS_DEFAULT_DECLARATION");
@ -34,7 +34,6 @@ public interface HaskellTypes {
IElementType HS_EXPRESSION = new HaskellCompositeElementType("HS_EXPRESSION");
IElementType HS_FIELDDECL = new HaskellCompositeElementType("HS_FIELDDECL");
IElementType HS_FILE_HEADER = new HaskellCompositeElementType("HS_FILE_HEADER");
IElementType HS_FILE_HEADER_PRAGMA = new HaskellCompositeElementType("HS_FILE_HEADER_PRAGMA");
IElementType HS_FIXITY_DECLARATION = new HaskellCompositeElementType("HS_FIXITY_DECLARATION");
IElementType HS_FOREIGN_DECLARATION = new HaskellCompositeElementType("HS_FOREIGN_DECLARATION");
IElementType HS_GENERAL_PRAGMA_CONTENT = new HaskellCompositeElementType("HS_GENERAL_PRAGMA_CONTENT");
@ -50,21 +49,18 @@ public interface HaskellTypes {
IElementType HS_IMPORT_QUALIFIED = new HaskellCompositeElementType("HS_IMPORT_QUALIFIED");
IElementType HS_IMPORT_QUALIFIED_AS = new HaskellCompositeElementType("HS_IMPORT_QUALIFIED_AS");
IElementType HS_IMPORT_SPEC = new HaskellCompositeElementType("HS_IMPORT_SPEC");
IElementType HS_INLINELIKE_PRAGMA = new HaskellCompositeElementType("HS_INLINELIKE_PRAGMA");
IElementType HS_INST = new HaskellCompositeElementType("HS_INST");
IElementType HS_INSTANCE_DECLARATION = new HaskellCompositeElementType("HS_INSTANCE_DECLARATION");
IElementType HS_INSTVAR = new HaskellCompositeElementType("HS_INSTVAR");
IElementType HS_KIND_SIGNATURE = new HaskellCompositeElementType("HS_KIND_SIGNATURE");
IElementType HS_LIST_TYPE = new HaskellCompositeElementType("HS_LIST_TYPE");
IElementType HS_MINIMAL_PRAGMA = new HaskellCompositeElementType("HS_MINIMAL_PRAGMA");
IElementType HS_MODID = HaskellElementTypeFactory.factory("HS_MODID");
IElementType HS_MODULE_BODY = new HaskellCompositeElementType("HS_MODULE_BODY");
IElementType HS_MODULE_DECLARATION = new HaskellCompositeElementType("HS_MODULE_DECLARATION");
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_OTHER_PRAGMA = new HaskellCompositeElementType("HS_OTHER_PRAGMA");
IElementType HS_OVERLAP_INCOHERENT_PRAGMA = new HaskellCompositeElementType("HS_OVERLAP_INCOHERENT_PRAGMA");
IElementType HS_PRAGMA = new HaskellCompositeElementType("HS_PRAGMA");
IElementType HS_QUALIFIER = new HaskellCompositeElementType("HS_QUALIFIER");
IElementType HS_Q_CON = new HaskellCompositeElementType("HS_Q_CON");
IElementType HS_Q_CON_QUALIFIER = new HaskellCompositeElementType("HS_Q_CON_QUALIFIER");
@ -76,13 +72,10 @@ public interface HaskellTypes {
IElementType HS_Q_NAMES = new HaskellCompositeElementType("HS_Q_NAMES");
IElementType HS_Q_VAR_CON = new HaskellCompositeElementType("HS_Q_VAR_CON");
IElementType HS_RESERVED_ID = new HaskellCompositeElementType("HS_RESERVED_ID");
IElementType HS_SCC_PRAGMA = new HaskellCompositeElementType("HS_SCC_PRAGMA");
IElementType HS_SCONTEXT = new HaskellCompositeElementType("HS_SCONTEXT");
IElementType HS_SHEBANG_LINE = new HaskellCompositeElementType("HS_SHEBANG_LINE");
IElementType HS_SIMPLECLASS = new HaskellCompositeElementType("HS_SIMPLECLASS");
IElementType HS_SIMPLETYPE = new HaskellCompositeElementType("HS_SIMPLETYPE");
IElementType HS_SOURCE_PRAGMA = new HaskellCompositeElementType("HS_SOURCE_PRAGMA");
IElementType HS_SPECIALIZE_PRAGMA = new HaskellCompositeElementType("HS_SPECIALIZE_PRAGMA");
IElementType HS_TEXT_LITERAL = new HaskellCompositeElementType("HS_TEXT_LITERAL");
IElementType HS_TOP_DECLARATION = new HaskellCompositeElementType("HS_TOP_DECLARATION");
IElementType HS_TOP_DECLARATION_LINE = new HaskellCompositeElementType("HS_TOP_DECLARATION_LINE");
@ -95,7 +88,6 @@ public interface HaskellTypes {
IElementType HS_TYPE_FAMILY_TYPE = new HaskellCompositeElementType("HS_TYPE_FAMILY_TYPE");
IElementType HS_TYPE_INSTANCE_DECLARATION = new HaskellCompositeElementType("HS_TYPE_INSTANCE_DECLARATION");
IElementType HS_TYPE_SIGNATURE = new HaskellCompositeElementType("HS_TYPE_SIGNATURE");
IElementType HS_UNPACK_NOUNPACK_PRAGMA = new HaskellCompositeElementType("HS_UNPACK_NOUNPACK_PRAGMA");
IElementType HS_VAR = new HaskellCompositeElementType("HS_VAR");
IElementType HS_VARID = HaskellElementTypeFactory.factory("HS_VARID");
IElementType HS_VAROP = new HaskellCompositeElementType("HS_VAROP");
@ -171,4 +163,182 @@ public interface HaskellTypes {
IElementType HS_VAR_ID = new HaskellTokenType("VAR_ID");
IElementType HS_VERTICAL_BAR = new HaskellTokenType("VERTICAL_BAR");
IElementType HS_WHERE = new HaskellTokenType("WHERE");
class Factory {
public static PsiElement createElement(ASTNode node) {
IElementType type = node.getElementType();
if (type == HS_CCONTEXT) {
return new HaskellCcontextImpl(node);
} else if (type == HS_CDECLS) {
return new HaskellCdeclsImpl(node);
} else if (type == HS_CDECL_DATA_DECLARATION) {
return new HaskellCdeclDataDeclarationImpl(node);
} else if (type == HS_CIDECLS) {
return new HaskellCideclsImpl(node);
} else if (type == HS_CLASS_DECLARATION) {
return new HaskellClassDeclarationImpl(node);
} else if (type == HS_CLAZZ) {
return new HaskellClazzImpl(node);
} else if (type == HS_CNAME) {
return new HaskellCnameImpl(node);
} else if (type == HS_CNAME_DOT_DOT) {
return new HaskellCnameDotDotImpl(node);
} else if (type == HS_COMMENTS) {
return new HaskellCommentsImpl(node);
} else if (type == HS_CON) {
return new HaskellConImpl(node);
} else if (type == HS_CONID) {
return new HaskellConidImpl(node);
} else if (type == HS_CONOP) {
return new HaskellConopImpl(node);
} else if (type == HS_CONSTR_1) {
return new HaskellConstr1Impl(node);
} else if (type == HS_CONSTR_2) {
return new HaskellConstr2Impl(node);
} else if (type == HS_CONSTR_3) {
return new HaskellConstr3Impl(node);
} else if (type == HS_CONSYM) {
return new HaskellConsymImpl(node);
} else if (type == HS_DATA_DECLARATION) {
return new HaskellDataDeclarationImpl(node);
} else if (type == HS_DATA_DECLARATION_DERIVING) {
return new HaskellDataDeclarationDerivingImpl(node);
} else if (type == HS_DEFAULT_DECLARATION) {
return new HaskellDefaultDeclarationImpl(node);
} else if (type == HS_DERIVING_DECLARATION) {
return new HaskellDerivingDeclarationImpl(node);
} else if (type == HS_DOT_DOT) {
return new HaskellDotDotImpl(node);
} else if (type == HS_EXPORT) {
return new HaskellExportImpl(node);
} else if (type == HS_EXPORTS) {
return new HaskellExportsImpl(node);
} else if (type == HS_EXPRESSION) {
return new HaskellExpressionImpl(node);
} else if (type == HS_FIELDDECL) {
return new HaskellFielddeclImpl(node);
} else if (type == HS_FILE_HEADER) {
return new HaskellFileHeaderImpl(node);
} else if (type == HS_FIXITY_DECLARATION) {
return new HaskellFixityDeclarationImpl(node);
} else if (type == HS_FOREIGN_DECLARATION) {
return new HaskellForeignDeclarationImpl(node);
} else if (type == HS_GENERAL_PRAGMA_CONTENT) {
return new HaskellGeneralPragmaContentImpl(node);
} else if (type == HS_GTYCON) {
return new HaskellGtyconImpl(node);
} else if (type == HS_IMPORT_DECLARATION) {
return new HaskellImportDeclarationImpl(node);
} else if (type == HS_IMPORT_DECLARATIONS) {
return new HaskellImportDeclarationsImpl(node);
} else if (type == HS_IMPORT_EMPTY_SPEC) {
return new HaskellImportEmptySpecImpl(node);
} else if (type == HS_IMPORT_HIDING) {
return new HaskellImportHidingImpl(node);
} else if (type == HS_IMPORT_HIDING_SPEC) {
return new HaskellImportHidingSpecImpl(node);
} else if (type == HS_IMPORT_ID) {
return new HaskellImportIdImpl(node);
} else if (type == HS_IMPORT_IDS_SPEC) {
return new HaskellImportIdsSpecImpl(node);
} else if (type == HS_IMPORT_PACKAGE_NAME) {
return new HaskellImportPackageNameImpl(node);
} else if (type == HS_IMPORT_QUALIFIED) {
return new HaskellImportQualifiedImpl(node);
} else if (type == HS_IMPORT_QUALIFIED_AS) {
return new HaskellImportQualifiedAsImpl(node);
} else if (type == HS_IMPORT_SPEC) {
return new HaskellImportSpecImpl(node);
} else if (type == HS_INST) {
return new HaskellInstImpl(node);
} else if (type == HS_INSTANCE_DECLARATION) {
return new HaskellInstanceDeclarationImpl(node);
} else if (type == HS_INSTVAR) {
return new HaskellInstvarImpl(node);
} else if (type == HS_KIND_SIGNATURE) {
return new HaskellKindSignatureImpl(node);
} else if (type == HS_LIST_TYPE) {
return new HaskellListTypeImpl(node);
} else if (type == HS_MODID) {
return new HaskellModidImpl(node);
} else if (type == HS_MODULE_BODY) {
return new HaskellModuleBodyImpl(node);
} else if (type == HS_MODULE_DECLARATION) {
return new HaskellModuleDeclarationImpl(node);
} else if (type == HS_NEWCONSTR) {
return new HaskellNewconstrImpl(node);
} else if (type == HS_NEWCONSTR_FIELDDECL) {
return new HaskellNewconstrFielddeclImpl(node);
} else if (type == HS_NEWTYPE_DECLARATION) {
return new HaskellNewtypeDeclarationImpl(node);
} else if (type == HS_PRAGMA) {
return new HaskellPragmaImpl(node);
} else if (type == HS_QUALIFIER) {
return new HaskellQualifierImpl(node);
} else if (type == HS_Q_CON) {
return new HaskellQConImpl(node);
} else if (type == HS_Q_CON_QUALIFIER) {
return new HaskellQConQualifierImpl(node);
} else if (type == HS_Q_CON_QUALIFIER_1) {
return new HaskellQConQualifier1Impl(node);
} else if (type == HS_Q_CON_QUALIFIER_2) {
return new HaskellQConQualifier2Impl(node);
} else if (type == HS_Q_CON_QUALIFIER_3) {
return new HaskellQConQualifier3Impl(node);
} else if (type == HS_Q_CON_QUALIFIER_4) {
return new HaskellQConQualifier4Impl(node);
} else if (type == HS_Q_NAME) {
return new HaskellQNameImpl(node);
} else if (type == HS_Q_NAMES) {
return new HaskellQNamesImpl(node);
} else if (type == HS_Q_VAR_CON) {
return new HaskellQVarConImpl(node);
} else if (type == HS_RESERVED_ID) {
return new HaskellReservedIdImpl(node);
} else if (type == HS_SCONTEXT) {
return new HaskellScontextImpl(node);
} else if (type == HS_SHEBANG_LINE) {
return new HaskellShebangLineImpl(node);
} else if (type == HS_SIMPLECLASS) {
return new HaskellSimpleclassImpl(node);
} else if (type == HS_SIMPLETYPE) {
return new HaskellSimpletypeImpl(node);
} else if (type == HS_TEXT_LITERAL) {
return new HaskellTextLiteralImpl(node);
} else if (type == HS_TOP_DECLARATION) {
return new HaskellTopDeclarationImpl(node);
} else if (type == HS_TOP_DECLARATION_LINE) {
return new HaskellTopDeclarationLineImpl(node);
} else if (type == HS_TTYPE) {
return new HaskellTtypeImpl(node);
} else if (type == HS_TTYPE_1) {
return new HaskellTtype1Impl(node);
} else if (type == HS_TTYPE_2) {
return new HaskellTtype2Impl(node);
} else if (type == HS_TYPE_DECLARATION) {
return new HaskellTypeDeclarationImpl(node);
} else if (type == HS_TYPE_EQUALITY) {
return new HaskellTypeEqualityImpl(node);
} else if (type == HS_TYPE_FAMILY_DECLARATION) {
return new HaskellTypeFamilyDeclarationImpl(node);
} else if (type == HS_TYPE_FAMILY_TYPE) {
return new HaskellTypeFamilyTypeImpl(node);
} else if (type == HS_TYPE_INSTANCE_DECLARATION) {
return new HaskellTypeInstanceDeclarationImpl(node);
} else if (type == HS_TYPE_SIGNATURE) {
return new HaskellTypeSignatureImpl(node);
} else if (type == HS_VAR) {
return new HaskellVarImpl(node);
} else if (type == HS_VARID) {
return new HaskellVaridImpl(node);
} else if (type == HS_VAROP) {
return new HaskellVaropImpl(node);
} else if (type == HS_VARSYM) {
return new HaskellVarsymImpl(node);
} else if (type == HS_VAR_CON) {
return new HaskellVarConImpl(node);
}
throw new AssertionError("Unknown element type: " + type);
}
}
}

13
gen/intellij/haskell/psi/HaskellUnpackNounpackPragma.java
View File

@ -1,13 +0,0 @@
// 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 HaskellUnpackNounpackPragma extends HaskellCompositeElement {
@NotNull
List<HaskellGeneralPragmaContent> getGeneralPragmaContentList();
}

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

@ -18,10 +18,6 @@ public class HaskellVisitor extends PsiElementVisitor {
visitCompositeElement(o);
}
public void visitCfilesPragma(@NotNull HaskellCfilesPragma o) {
visitCompositeElement(o);
}
public void visitCidecls(@NotNull HaskellCidecls o) {
visitCompositeElement(o);
}
@ -74,10 +70,6 @@ public class HaskellVisitor extends PsiElementVisitor {
visitNamedElement(o);
}
public void visitCtypePragma(@NotNull HaskellCtypePragma o) {
visitCompositeElement(o);
}
public void visitDataDeclaration(@NotNull HaskellDataDeclaration o) {
visitDataConstructorDeclarationElement(o);
}
@ -119,10 +111,6 @@ public class HaskellVisitor extends PsiElementVisitor {
visitCompositeElement(o);
}
public void visitFileHeaderPragma(@NotNull HaskellFileHeaderPragma o) {
visitCompositeElement(o);
}
public void visitFixityDeclaration(@NotNull HaskellFixityDeclaration o) {
visitCompositeElement(o);
}
@ -183,10 +171,6 @@ public class HaskellVisitor extends PsiElementVisitor {
visitCompositeElement(o);
}
public void visitInlinelikePragma(@NotNull HaskellInlinelikePragma o) {
visitCompositeElement(o);
}
public void visitInst(@NotNull HaskellInst o) {
visitCompositeElement(o);
}
@ -207,10 +191,6 @@ public class HaskellVisitor extends PsiElementVisitor {
visitCompositeElement(o);
}
public void visitMinimalPragma(@NotNull HaskellMinimalPragma o) {
visitCompositeElement(o);
}
public void visitModid(@NotNull HaskellModid o) {
visitNamedElement(o);
}
@ -235,11 +215,7 @@ public class HaskellVisitor extends PsiElementVisitor {
visitDataConstructorDeclarationElement(o);
}
public void visitOtherPragma(@NotNull HaskellOtherPragma o) {
visitCompositeElement(o);
}
public void visitOverlapIncoherentPragma(@NotNull HaskellOverlapIncoherentPragma o) {
public void visitPragma(@NotNull HaskellPragma o) {
visitCompositeElement(o);
}
@ -287,10 +263,6 @@ public class HaskellVisitor extends PsiElementVisitor {
visitCompositeElement(o);
}
public void visitSccPragma(@NotNull HaskellSccPragma o) {
visitCompositeElement(o);
}
public void visitScontext(@NotNull HaskellScontext o) {
visitCompositeElement(o);
}
@ -307,14 +279,6 @@ public class HaskellVisitor extends PsiElementVisitor {
visitCompositeElement(o);
}
public void visitSourcePragma(@NotNull HaskellSourcePragma o) {
visitCompositeElement(o);
}
public void visitSpecializePragma(@NotNull HaskellSpecializePragma o) {
visitCompositeElement(o);
}
public void visitTextLiteral(@NotNull HaskellTextLiteral o) {
visitStringLiteralElement(o);
// visitPsiLanguageInjectionHost(o);
@ -364,10 +328,6 @@ public class HaskellVisitor extends PsiElementVisitor {
visitDeclarationElement(o);
}
public void visitUnpackNounpackPragma(@NotNull HaskellUnpackNounpackPragma o) {
visitCompositeElement(o);
}
public void visitVar(@NotNull HaskellVar o) {
visitCNameElement(o);
}

12
gen/intellij/haskell/psi/impl/HaskellCdeclDataDeclarationImpl.java
View File

@ -25,18 +25,18 @@ public class HaskellCdeclDataDeclarationImpl extends HaskellCompositeElementImpl
else super.accept(visitor);
}
@Override
@Nullable
public HaskellCtypePragma getCtypePragma() {
return PsiTreeUtil.getChildOfType(this, HaskellCtypePragma.class);
}
@Override
@NotNull
public List<HaskellKindSignature> getKindSignatureList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellKindSignature.class);
}
@Override
@Nullable
public HaskellPragma getPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellPragma.class);
}
@Override
@NotNull
public List<HaskellQName> getQNameList() {

26
gen/intellij/haskell/psi/impl/HaskellCdeclsImpl.java
View File

@ -48,12 +48,6 @@ public class HaskellCdeclsImpl extends HaskellCompositeElementImpl implements Ha
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellDotDot.class);
}
@Override
@NotNull
public List<HaskellInlinelikePragma> getInlinelikePragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellInlinelikePragma.class);
}
@Override
@NotNull
public List<HaskellInstanceDeclaration> getInstanceDeclarationList() {
@ -62,14 +56,14 @@ public class HaskellCdeclsImpl extends HaskellCompositeElementImpl implements Ha
@Override
@NotNull
public List<HaskellMinimalPragma> getMinimalPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellMinimalPragma.class);
public List<HaskellNewtypeDeclaration> getNewtypeDeclarationList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellNewtypeDeclaration.class);
}
@Override
@NotNull
public List<HaskellNewtypeDeclaration> getNewtypeDeclarationList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellNewtypeDeclaration.class);
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
@Override
@ -84,18 +78,6 @@ public class HaskellCdeclsImpl extends HaskellCompositeElementImpl implements Ha
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellReservedId.class);
}
@Override
@NotNull
public List<HaskellSccPragma> getSccPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellSccPragma.class);
}
@Override
@NotNull
public List<HaskellSpecializePragma> getSpecializePragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellSpecializePragma.class);
}
@Override
@NotNull
public List<HaskellTextLiteral> getTextLiteralList() {

35
gen/intellij/haskell/psi/impl/HaskellCfilesPragmaImpl.java
View File

@ -1,35 +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 com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellCfilesPragma;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellCfilesPragmaImpl extends HaskellCompositeElementImpl implements HaskellCfilesPragma {
public HaskellCfilesPragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitCfilesPragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

26
gen/intellij/haskell/psi/impl/HaskellCideclsImpl.java
View File

@ -42,12 +42,6 @@ public class HaskellCideclsImpl extends HaskellCompositeElementImpl implements H
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellDotDot.class);
}
@Override
@NotNull
public List<HaskellInlinelikePragma> getInlinelikePragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellInlinelikePragma.class);
}
@Override
@NotNull
public List<HaskellInstanceDeclaration> getInstanceDeclarationList() {
@ -56,14 +50,14 @@ public class HaskellCideclsImpl extends HaskellCompositeElementImpl implements H
@Override
@NotNull
public List<HaskellMinimalPragma> getMinimalPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellMinimalPragma.class);
public List<HaskellNewtypeDeclaration> getNewtypeDeclarationList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellNewtypeDeclaration.class);
}
@Override
@NotNull
public List<HaskellNewtypeDeclaration> getNewtypeDeclarationList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellNewtypeDeclaration.class);
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
@Override
@ -78,18 +72,6 @@ public class HaskellCideclsImpl extends HaskellCompositeElementImpl implements H
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellReservedId.class);
}
@Override
@NotNull
public List<HaskellSccPragma> getSccPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellSccPragma.class);
}
@Override
@NotNull
public List<HaskellSpecializePragma> getSpecializePragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellSpecializePragma.class);
}
@Override
@NotNull
public List<HaskellTextLiteral> getTextLiteralList() {

12
gen/intellij/haskell/psi/impl/HaskellConstr1Impl.java
View File

@ -31,16 +31,16 @@ public class HaskellConstr1Impl extends HaskellCompositeElementImpl implements H
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellFielddecl.class);
}
@Override
@NotNull
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
@Override
@Nullable
public HaskellQName getQName() {
return PsiTreeUtil.getChildOfType(this, HaskellQName.class);
}
@Override
@NotNull
public List<HaskellUnpackNounpackPragma> getUnpackNounpackPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellUnpackNounpackPragma.class);
}
}

12
gen/intellij/haskell/psi/impl/HaskellConstr2Impl.java
View File

@ -25,6 +25,12 @@ public class HaskellConstr2Impl extends HaskellCompositeElementImpl implements H
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
@Override
@Nullable
public HaskellQName getQName() {
@ -37,10 +43,4 @@ public class HaskellConstr2Impl extends HaskellCompositeElementImpl implements H
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellTtype.class);
}
@Override
@NotNull
public List<HaskellUnpackNounpackPragma> getUnpackNounpackPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellUnpackNounpackPragma.class);
}
}

10
gen/intellij/haskell/psi/impl/HaskellConstr3Impl.java
View File

@ -5,8 +5,8 @@ import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellConstr3;
import intellij.haskell.psi.HaskellPragma;
import intellij.haskell.psi.HaskellTtype;
import intellij.haskell.psi.HaskellUnpackNounpackPragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
@ -29,14 +29,14 @@ public class HaskellConstr3Impl extends HaskellCompositeElementImpl implements H
@Override
@NotNull
public List<HaskellTtype> getTtypeList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellTtype.class);
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
@Override
@NotNull
public List<HaskellUnpackNounpackPragma> getUnpackNounpackPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellUnpackNounpackPragma.class);
public List<HaskellTtype> getTtypeList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellTtype.class);
}
}

35
gen/intellij/haskell/psi/impl/HaskellCtypePragmaImpl.java
View File

@ -1,35 +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 com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellCtypePragma;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellCtypePragmaImpl extends HaskellCompositeElementImpl implements HaskellCtypePragma {
public HaskellCtypePragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitCtypePragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

12
gen/intellij/haskell/psi/impl/HaskellDataDeclarationImpl.java
View File

@ -52,12 +52,6 @@ public class HaskellDataDeclarationImpl extends HaskellCompositeElementImpl impl
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellConstr3.class);
}
@Override
@Nullable
public HaskellCtypePragma getCtypePragma() {
return PsiTreeUtil.getChildOfType(this, HaskellCtypePragma.class);
}
@Override
@Nullable
public HaskellDataDeclarationDeriving getDataDeclarationDeriving() {
@ -70,6 +64,12 @@ public class HaskellDataDeclarationImpl extends HaskellCompositeElementImpl impl
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellKindSignature.class);
}
@Override
@Nullable
public HaskellPragma getPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellPragma.class);
}
@Override
@NotNull
public List<HaskellQName> getQNameList() {

10
gen/intellij/haskell/psi/impl/HaskellExpressionImpl.java
View File

@ -32,8 +32,8 @@ public class HaskellExpressionImpl extends HaskellExpressionElementImpl implemen
@Override
@NotNull
public List<HaskellInlinelikePragma> getInlinelikePragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellInlinelikePragma.class);
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
@Override
@ -48,12 +48,6 @@ public class HaskellExpressionImpl extends HaskellExpressionElementImpl implemen
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellReservedId.class);
}
@Override
@NotNull
public List<HaskellSccPragma> getSccPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellSccPragma.class);
}
@Override
@NotNull
public List<HaskellTextLiteral> getTextLiteralList() {

12
gen/intellij/haskell/psi/impl/HaskellFielddeclImpl.java
View File

@ -25,6 +25,12 @@ public class HaskellFielddeclImpl extends HaskellCompositeElementImpl implements
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
@Override
@NotNull
public List<HaskellQName> getQNameList() {
@ -49,10 +55,4 @@ public class HaskellFielddeclImpl extends HaskellCompositeElementImpl implements
return PsiTreeUtil.getChildOfType(this, HaskellTtype.class);
}
@Override
@NotNull
public List<HaskellUnpackNounpackPragma> getUnpackNounpackPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellUnpackNounpackPragma.class);
}
}

6
gen/intellij/haskell/psi/impl/HaskellFileHeaderImpl.java
View File

@ -5,7 +5,7 @@ import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellFileHeader;
import intellij.haskell.psi.HaskellFileHeaderPragma;
import intellij.haskell.psi.HaskellPragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
@ -28,8 +28,8 @@ public class HaskellFileHeaderImpl extends HaskellCompositeElementImpl implement
@Override
@NotNull
public List<HaskellFileHeaderPragma> getFileHeaderPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellFileHeaderPragma.class);
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
}

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

@ -1,35 +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 com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellFileHeaderPragma;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellFileHeaderPragmaImpl extends HaskellCompositeElementImpl implements HaskellFileHeaderPragma {
public HaskellFileHeaderPragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitFileHeaderPragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

92
gen/intellij/haskell/psi/impl/HaskellImportDeclarationImpl.java
View File

@ -1,69 +1,67 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi.impl;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import static intellij.haskell.psi.HaskellTypes.*;
import intellij.haskell.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import scala.Option;
public class HaskellImportDeclarationImpl extends HaskellCompositeElementImpl implements HaskellImportDeclaration {
public HaskellImportDeclarationImpl(ASTNode node) {
super(node);
}
public HaskellImportDeclarationImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitImportDeclaration(this);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitImportDeclaration(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor)visitor);
else super.accept(visitor);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public HaskellImportPackageName getImportPackageName() {
return PsiTreeUtil.getChildOfType(this, HaskellImportPackageName.class);
}
@Override
@Nullable
public HaskellImportPackageName getImportPackageName() {
return PsiTreeUtil.getChildOfType(this, HaskellImportPackageName.class);
}
@Override
@Nullable
public HaskellImportQualified getImportQualified() {
return PsiTreeUtil.getChildOfType(this, HaskellImportQualified.class);
}
@Override
@Nullable
public HaskellImportQualified getImportQualified() {
return PsiTreeUtil.getChildOfType(this, HaskellImportQualified.class);
}
@Override
@Nullable
public HaskellImportQualifiedAs getImportQualifiedAs() {
return PsiTreeUtil.getChildOfType(this, HaskellImportQualifiedAs.class);
}
@Override
@Nullable
public HaskellImportQualifiedAs getImportQualifiedAs() {
return PsiTreeUtil.getChildOfType(this, HaskellImportQualifiedAs.class);
}
@Override
@Nullable
public HaskellImportSpec getImportSpec() {
return PsiTreeUtil.getChildOfType(this, HaskellImportSpec.class);
}
@Override
@Nullable
public HaskellImportSpec getImportSpec() {
return PsiTreeUtil.getChildOfType(this, HaskellImportSpec.class);
}
@Override
@Nullable
public HaskellModid getModid() {
return PsiTreeUtil.getChildOfType(this, HaskellModid.class);
}
@Override
@Nullable
public HaskellModid getModid() {
return PsiTreeUtil.getChildOfType(this, HaskellModid.class);
}
@Override
@Nullable
public HaskellSourcePragma getSourcePragma() {
return PsiTreeUtil.getChildOfType(this, HaskellSourcePragma.class);
}
@Override
@Nullable
public HaskellPragma getPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellPragma.class);
}
public Option<String> getModuleName() {
return HaskellPsiImplUtil.getModuleName(this);
}
public Option<String> getModuleName() {
return HaskellPsiImplUtil.getModuleName(this);
}
}

52
gen/intellij/haskell/psi/impl/HaskellImportDeclarationsImpl.java
View File

@ -1,40 +1,42 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi.impl;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import static intellij.haskell.psi.HaskellTypes.*;
import intellij.haskell.psi.*;
import intellij.haskell.psi.HaskellImportDeclaration;
import intellij.haskell.psi.HaskellImportDeclarations;
import intellij.haskell.psi.HaskellPragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellImportDeclarationsImpl extends HaskellCompositeElementImpl implements HaskellImportDeclarations {
public HaskellImportDeclarationsImpl(ASTNode node) {
super(node);
}
public HaskellImportDeclarationsImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitImportDeclarations(this);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitImportDeclarations(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor)visitor);
else super.accept(visitor);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellCfilesPragma> getCfilesPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellCfilesPragma.class);
}
@Override
@NotNull
public List<HaskellImportDeclaration> getImportDeclarationList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellImportDeclaration.class);
}
@Override
@NotNull
public List<HaskellImportDeclaration> getImportDeclarationList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellImportDeclaration.class);
}
@Override
@NotNull
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
}

35
gen/intellij/haskell/psi/impl/HaskellInlinelikePragmaImpl.java
View File

@ -1,35 +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 com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellInlinelikePragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellInlinelikePragmaImpl extends HaskellCompositeElementImpl implements HaskellInlinelikePragma {
public HaskellInlinelikePragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitInlinelikePragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

4
gen/intellij/haskell/psi/impl/HaskellInstanceDeclarationImpl.java
View File

@ -42,8 +42,8 @@ public class HaskellInstanceDeclarationImpl extends HaskellCompositeElementImpl
@Override
@Nullable
public HaskellOverlapIncoherentPragma getOverlapIncoherentPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellOverlapIncoherentPragma.class);
public HaskellPragma getPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellPragma.class);
}
@Override

35
gen/intellij/haskell/psi/impl/HaskellMinimalPragmaImpl.java
View File

@ -1,35 +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 com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellMinimalPragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellMinimalPragmaImpl extends HaskellCompositeElementImpl implements HaskellMinimalPragma {
public HaskellMinimalPragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitMinimalPragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

12
gen/intellij/haskell/psi/impl/HaskellModuleDeclarationImpl.java
View File

@ -11,8 +11,6 @@ import org.jetbrains.annotations.Nullable;
import scala.Option;
import scala.collection.Seq;
import java.util.List;
public class HaskellModuleDeclarationImpl extends HaskellCompositeElementImpl implements HaskellModuleDeclaration {
public HaskellModuleDeclarationImpl(ASTNode node) {
@ -36,14 +34,14 @@ public class HaskellModuleDeclarationImpl extends HaskellCompositeElementImpl im
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
public HaskellModid getModid() {
return notNullChild(PsiTreeUtil.getChildOfType(this, HaskellModid.class));
}
@Override
@NotNull
public HaskellModid getModid() {
return notNullChild(PsiTreeUtil.getChildOfType(this, HaskellModid.class));
@Nullable
public HaskellPragma getPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellPragma.class);
}
public String getName() {

108
gen/intellij/haskell/psi/impl/HaskellNewtypeDeclarationImpl.java
View File

@ -1,81 +1,79 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi.impl;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.navigation.ItemPresentation;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import static intellij.haskell.psi.HaskellTypes.*;
import intellij.haskell.psi.*;
import com.intellij.navigation.ItemPresentation;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import scala.Option;
import scala.collection.Seq;
public class HaskellNewtypeDeclarationImpl extends HaskellCompositeElementImpl implements HaskellNewtypeDeclaration {
public HaskellNewtypeDeclarationImpl(ASTNode node) {
super(node);
}
public HaskellNewtypeDeclarationImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitNewtypeDeclaration(this);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitNewtypeDeclaration(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor)visitor);
else super.accept(visitor);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@Nullable
public HaskellCcontext getCcontext() {
return PsiTreeUtil.getChildOfType(this, HaskellCcontext.class);
}
@Override
@Nullable
public HaskellCcontext getCcontext() {
return PsiTreeUtil.getChildOfType(this, HaskellCcontext.class);
}
@Override
@Nullable
public HaskellCtypePragma getCtypePragma() {
return PsiTreeUtil.getChildOfType(this, HaskellCtypePragma.class);
}
@Override
@NotNull
public HaskellNewconstr getNewconstr() {
return notNullChild(PsiTreeUtil.getChildOfType(this, HaskellNewconstr.class));
}
@Override
@NotNull
public HaskellNewconstr getNewconstr() {
return notNullChild(PsiTreeUtil.getChildOfType(this, HaskellNewconstr.class));
}
@Override
@Nullable
public HaskellPragma getPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellPragma.class);
}
@Override
@NotNull
public HaskellSimpletype getSimpletype() {
return notNullChild(PsiTreeUtil.getChildOfType(this, HaskellSimpletype.class));
}
@Override
@NotNull
public HaskellSimpletype getSimpletype() {
return notNullChild(PsiTreeUtil.getChildOfType(this, HaskellSimpletype.class));
}
@Override
@Nullable
public HaskellTtype getTtype() {
return PsiTreeUtil.getChildOfType(this, HaskellTtype.class);
}
@Override
@Nullable
public HaskellTtype getTtype() {
return PsiTreeUtil.getChildOfType(this, HaskellTtype.class);
}
public String getName() {
return HaskellPsiImplUtil.getName(this);
}
public String getName() {
return HaskellPsiImplUtil.getName(this);
}
public ItemPresentation getPresentation() {
return HaskellPsiImplUtil.getPresentation(this);
}
public ItemPresentation getPresentation() {
return HaskellPsiImplUtil.getPresentation(this);
}
public Seq<HaskellNamedElement> getIdentifierElements() {
return HaskellPsiImplUtil.getIdentifierElements(this);
}
public Seq<HaskellNamedElement> getIdentifierElements() {
return HaskellPsiImplUtil.getIdentifierElements(this);
}
public Option<String> getModuleName() {
return HaskellPsiImplUtil.getModuleName(this);
}
public Option<String> getModuleName() {
return HaskellPsiImplUtil.getModuleName(this);
}
public HaskellNamedElement getDataTypeConstructor() {
return HaskellPsiImplUtil.getDataTypeConstructor(this);
}
public HaskellNamedElement getDataTypeConstructor() {
return HaskellPsiImplUtil.getDataTypeConstructor(this);
}
}

35
gen/intellij/haskell/psi/impl/HaskellOtherPragmaImpl.java
View File

@ -1,35 +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 com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellOtherPragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellOtherPragmaImpl extends HaskellCompositeElementImpl implements HaskellOtherPragma {
public HaskellOtherPragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitOtherPragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

34
gen/intellij/haskell/psi/impl/HaskellOverlapIncoherentPragmaImpl.java
View File

@ -1,34 +0,0 @@
// This is a generated file. Not intended for manual editing.
package intellij.haskell.psi.impl;
import java.util.List;
import org.jetbrains.annotations.*;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import static intellij.haskell.psi.HaskellTypes.*;
import intellij.haskell.psi.*;
public class HaskellOverlapIncoherentPragmaImpl extends HaskellCompositeElementImpl implements HaskellOverlapIncoherentPragma {
public HaskellOverlapIncoherentPragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitOverlapIncoherentPragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor)visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

8
gen/intellij/haskell/psi/impl/HaskellSccPragmaImpl.java → gen/intellij/haskell/psi/impl/HaskellPragmaImpl.java
View File

@ -5,20 +5,20 @@ import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElementVisitor;
import com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellSccPragma;
import intellij.haskell.psi.HaskellPragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellSccPragmaImpl extends HaskellCompositeElementImpl implements HaskellSccPragma {
public class HaskellPragmaImpl extends HaskellCompositeElementImpl implements HaskellPragma {
public HaskellSccPragmaImpl(ASTNode node) {
public HaskellPragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitSccPragma(this);
visitor.visitPragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {

10
gen/intellij/haskell/psi/impl/HaskellShebangLineImpl.java
View File

@ -32,8 +32,8 @@ public class HaskellShebangLineImpl extends HaskellCompositeElementImpl implemen
@Override
@NotNull
public List<HaskellInlinelikePragma> getInlinelikePragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellInlinelikePragma.class);
public List<HaskellPragma> getPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellPragma.class);
}
@Override
@ -48,12 +48,6 @@ public class HaskellShebangLineImpl extends HaskellCompositeElementImpl implemen
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellReservedId.class);
}
@Override
@NotNull
public List<HaskellSccPragma> getSccPragmaList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellSccPragma.class);
}
@Override
@NotNull
public List<HaskellTextLiteral> getTextLiteralList() {

35
gen/intellij/haskell/psi/impl/HaskellSourcePragmaImpl.java
View File

@ -1,35 +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 com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellSourcePragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellSourcePragmaImpl extends HaskellCompositeElementImpl implements HaskellSourcePragma {
public HaskellSourcePragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitSourcePragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

35
gen/intellij/haskell/psi/impl/HaskellSpecializePragmaImpl.java
View File

@ -1,35 +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 com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellSpecializePragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellSpecializePragmaImpl extends HaskellCompositeElementImpl implements HaskellSpecializePragma {
public HaskellSpecializePragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitSpecializePragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

4
gen/intellij/haskell/psi/impl/HaskellTopDeclarationImpl.java
View File

@ -79,8 +79,8 @@ public class HaskellTopDeclarationImpl extends HaskellCompositeElementImpl imple
@Override
@Nullable
public HaskellOtherPragma getOtherPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellOtherPragma.class);
public HaskellPragma getPragma() {
return PsiTreeUtil.getChildOfType(this, HaskellPragma.class);
}
@Override

35
gen/intellij/haskell/psi/impl/HaskellUnpackNounpackPragmaImpl.java
View File

@ -1,35 +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 com.intellij.psi.util.PsiTreeUtil;
import intellij.haskell.psi.HaskellGeneralPragmaContent;
import intellij.haskell.psi.HaskellUnpackNounpackPragma;
import intellij.haskell.psi.HaskellVisitor;
import org.jetbrains.annotations.NotNull;
import java.util.List;
public class HaskellUnpackNounpackPragmaImpl extends HaskellCompositeElementImpl implements HaskellUnpackNounpackPragma {
public HaskellUnpackNounpackPragmaImpl(ASTNode node) {
super(node);
}
public void accept(@NotNull HaskellVisitor visitor) {
visitor.visitUnpackNounpackPragma(this);
}
public void accept(@NotNull PsiElementVisitor visitor) {
if (visitor instanceof HaskellVisitor) accept((HaskellVisitor) visitor);
else super.accept(visitor);
}
@Override
@NotNull
public List<HaskellGeneralPragmaContent> getGeneralPragmaContentList() {
return PsiTreeUtil.getChildrenOfTypeAsList(this, HaskellGeneralPragmaContent.class);
}
}

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

@ -62,7 +62,6 @@ escape = \\({charesc}|{ascii}|({digit}+)|(o({octit}+))|(x({hexit}+)
character_literal = (\'([^\'\\\n]|{escape})\')
string_literal = \"([^\"\\\n]|{escape}|{gap})*(\"|\n)
double_quote = "\""
// ascSymbol except reservedop
exclamation_mark = "!"

2
src/main/scala/intellij/haskell/annotator/HaskellAnnotator.scala
View File

@ -345,7 +345,7 @@ class LanguageExtensionIntentionAction(languageExtension: String) extends Haskel
val languagePragmaElement = HaskellElementFactory.createLanguagePragma(project, s"{-# LANGUAGE $languageExtension #-}\n")
Option(PsiTreeUtil.findChildOfType(file, classOf[HaskellFileHeader])) match {
case Some(fh) =>
val lastPragmaElement = PsiTreeUtil.findChildrenOfType(fh, classOf[HaskellFileHeaderPragma]).asScala.lastOption.orNull
val lastPragmaElement = PsiTreeUtil.findChildrenOfType(fh, classOf[HaskellPragma]).asScala.lastOption.orNull
fh.addAfter(languagePragmaElement, lastPragmaElement)
case None =>
Option(file.getFirstChild) match {

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

@ -618,7 +618,7 @@ object HaskellCompletionContributor {
private case class ImportWithIds(moduleName: String, ids: Iterable[String], qualified: Boolean, as: Option[String]) extends ImportInfo
def isNoImplicitPreludeActive(info: StackComponentInfo, psiFile: PsiFile): Boolean = {
info.isImplicitPreludeActive || ApplicationUtil.runReadAction(HaskellPsiUtil.findLanguageExtensions(psiFile)).flatMap(_.getGeneralPragmaContentList.asScala).exists(p => ApplicationUtil.runReadAction(p.getText).contains("NoImplicitPrelude"))
info.isImplicitPreludeActive || ApplicationUtil.runReadAction(HaskellPsiUtil.findLanguageExtensions(psiFile)).exists(p => ApplicationUtil.runReadAction(p.getText).contains("NoImplicitPrelude"))
}
private def getFullImportedModules(implicitPreludeActive: Boolean, psiFile: PsiFile, importDeclarations: Iterable[HaskellImportDeclaration]): Iterable[ImportFull] = {

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

@ -55,25 +55,18 @@
program ::= onl shebang_line? onl file_header onl module_body
shebang_line ::= "#!" general_id+
file_header ::= (file_header_pragma onl)*
private pragma ::= PRAGMA_START general_pragma_content* PRAGMA_END {pin=1}
file_header_pragma ::= pragma
other_pragma ::= pragma
file_header ::= (pragma onl)*
pragma ::= PRAGMA_START general_pragma_content* PRAGMA_END {pin=1}
general_pragma_content ::= ONE_PRAGMA | PRAGMA_SEP | CHARACTER_LITERAL | STRING_LITERAL
module_body ::= module_declaration onl body | onl body
module_declaration ::= MODULE modid onl pragma? onl (exports onl)? WHERE
private body ::= import_declarations top_declarations (NEWLINE | DIRECTIVE)*
cfiles_pragma ::= pragma
import_declarations ::= ((import_declaration | cfiles_pragma | DIRECTIVE) onl)*
import_declarations ::= ((import_declaration | pragma | DIRECTIVE) onl)*
private top_declarations ::= (top_declaration_line (NEWLINE | DIRECTIVE)*)* top_declaration?
source_pragma ::= pragma
import_declaration ::= IMPORT (onls source_pragma)? (onls import_qualified)? (onls import_package_name)? onls modid onls import_qualified_as? onls import_spec? {methods=[getModuleName] pin=1}
import_declaration ::= IMPORT (onls pragma)? (onls import_qualified)? (onls import_package_name)? onls modid onls import_qualified_as? onls import_spec? {methods=[getModuleName] pin=1}
import_qualified ::= "qualified"
import_qualified_as ::= "as" qualifier
import_spec ::= import_ids_spec |
@ -90,7 +83,7 @@ import_package_name ::= text_literal
top_declaration_line ::= top_declaration SEMICOLON? NEWLINE
top_declaration ::= type_declaration | data_declaration | newtype_declaration | class_declaration | instance_declaration | default_declaration |
foreign_declaration | type_family_declaration | deriving_declaration | type_instance_declaration | type_signature |
other_pragma | fixity_declaration | expression | DIRECTIVE
pragma | fixity_declaration | expression | DIRECTIVE
type_declaration ::= TYPE onls simpletype onls COLON_COLON onls ttype |
TYPE onls simpletype onls (EQUAL | WHERE) onls (ttype | type_signature) (DOUBLE_RIGHT_ARROW ttype)? |
@ -99,23 +92,21 @@ type_declaration ::= TYPE onls simpletype onls COLON_COLON onls ttype
TYPE onls simpletype
ctype_pragma ::= pragma
data_declaration ::= DATA (onls ctype_pragma)? onls INSTANCE? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* onls (EQUAL | WHERE)?
data_declaration ::= DATA (onls pragma)? onls INSTANCE? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* onls (EQUAL | WHERE)?
onls (type_signature (nls type_signature)* | constrs) (onls data_declaration_deriving)? |
DATA (onls ctype_pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* (onls data_declaration_deriving)?
DATA (onls pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls (COLON_COLON ttype)? onls q_name* (onls data_declaration_deriving)?
kind_signature ::= q_name COLON_COLON ttype
data_declaration_deriving ::= (DERIVING onl ttype | DERIVING onl LEFT_PAREN ttype (onl COMMA onl ttype)* onl RIGHT_PAREN)+
newtype_declaration ::= NEWTYPE onls INSTANCE? onls ctype_pragma? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls EQUAL onls newconstr (onls DERIVING onls ttype)?
newtype_declaration ::= NEWTYPE onls INSTANCE? onls pragma? onls (ccontext onls DOUBLE_RIGHT_ARROW)? onls simpletype onls EQUAL onls newconstr (onls DERIVING onls ttype)?
class_declaration ::= CLASS onls (scontext onls DOUBLE_RIGHT_ARROW)? onls (q_name+ | ttype) onls (q_name | LEFT_PAREN ttype (onls COMMA onls ttype)* RIGHT_PAREN)*
(onls VERTICAL_BAR onls ttype (onls COMMA onls ttype)*)? onls WHERE? onls cdecls? |
CLASS onls scontext onls DOUBLE_RIGHT_ARROW onls (q_name+ | ttype) onls WHERE? onls cdecls? // seen in Control.Lens.Internal.Indexed
overlap_incoherent_pragma ::= pragma
instance_declaration ::= INSTANCE onls ("OVERLAPPABLE_" | "OVERLAPPING_" | overlap_incoherent_pragma)? onls (var_con+ DOT)? onls (scontext onls DOUBLE_RIGHT_ARROW)? onls
instance_declaration ::= INSTANCE onls ("OVERLAPPABLE_" | "OVERLAPPING_" | pragma)? onls (var_con+ DOT)? onls (scontext onls DOUBLE_RIGHT_ARROW)? onls
(type_equality | q_name onls inst (onls WHERE (onls cidecls)?)?) // this way of using type equality in Data.Type.Equality
type_equality ::= q_name+ TILDE q_name+
@ -178,14 +169,13 @@ q_names ::= q_name (COMMA q_name)*
gtycon ::= QUOTE? q_name | LEFT_PAREN RIGHT_ARROW RIGHT_PAREN | LEFT_PAREN RIGHT_PAREN | QUOTE? LEFT_BRACKET RIGHT_BRACKET | LEFT_PAREN COMMA (COMMA)* RIGHT_PAREN
unpack_nounpack_pragma ::= pragma
private constrs ::= constr (onls VERTICAL_BAR onls constr)*
private constr ::= (type_signature | constr1 | constr2 | constr3)
constr1 ::= unpack_nounpack_pragma? (onls q_name)? (onls unpack_nounpack_pragma)? onls LEFT_BRACE onl fielddecl? ((onl COMMA)? onl fielddecl)* onl RIGHT_BRACE
constr2 ::= unpack_nounpack_pragma? onls (ttype | q_name | LEFT_PAREN q_name* RIGHT_PAREN | LEFT_BRACKET q_name* RIGHT_BRACKET) (onls unpack_nounpack_pragma onls)? ((onls unpack_nounpack_pragma)? onls ttype (onls unpack_nounpack_pragma)?)* // Base.hs: data () = () and GHC.Types.hs: data [] a = [] | a : [a]
constr3 ::= (onls unpack_nounpack_pragma? onls ttype)+
constr1 ::= pragma? (onls q_name)? (onls pragma)? onls LEFT_BRACE onl fielddecl? ((onl COMMA)? onl fielddecl)* onl RIGHT_BRACE
constr2 ::= pragma? onls (ttype | q_name | LEFT_PAREN q_name* RIGHT_PAREN | LEFT_BRACKET q_name* RIGHT_BRACKET) (onls pragma onls)? ((onls pragma)? onls ttype (onls pragma)?)* // Base.hs: data () = () and GHC.Types.hs: data [] a = [] | a : [a]
constr3 ::= (onls pragma? onls ttype)+
fielddecl ::= q_names (onl COLON_COLON unpack_nounpack_pragma? (onls ("forall" | FORALL) (onls q_name)+)? (onls scontext onls DOUBLE_RIGHT_ARROW)? unpack_nounpack_pragma? onls ttype)?
fielddecl ::= q_names (onl COLON_COLON pragma? (onls ("forall" | FORALL) (onls q_name)+)? (onls scontext onls DOUBLE_RIGHT_ARROW)? pragma? onls ttype)?
private atype ::= (("forall" | FORALL) ((onl q_name+ onl LEFT_PAREN onl (type_signature | ttype) onl (COMMA onl (type_signature | ttype))* onl RIGHT_PAREN)+ | (onl q_name)+) (onl DOUBLE_RIGHT_ARROW onl ttype)? |
(q_name | UNDERSCORE)* LEFT_PAREN ttype1 RIGHT_PAREN |
@ -248,25 +238,20 @@ newconstr_fielddecl ::= q_name onls LEFT_BRACE? onls type_signature onls
cdecls ::= cdecl (nls cdecl)*
cidecls ::= cidecl (nls cidecl)*
inlinelike_pragma ::= pragma
specialize_pragma ::= pragma
minimal_pragma ::= pragma
// copy of data_declaration but without all onls
cdecl_data_declaration ::= DATA (onls ctype_pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype (onls LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* (onls COLON_COLON ttype)? q_name*
cdecl_data_declaration ::= DATA (onls pragma)? onls (LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* onls simpletype (onls LEFT_PAREN onls kind_signature onls RIGHT_PAREN)* (onls COLON_COLON ttype)? q_name*
private cdecl ::= type_signature | cdecl_data_declaration | cidecl
private cidecl ::= inlinelike_pragma | specialize_pragma | instance_declaration | default_declaration |
newtype_declaration | data_declaration | minimal_pragma | type_declaration | type_family_declaration | line_expression
private cidecl ::= pragma | instance_declaration | default_declaration |
newtype_declaration | data_declaration | type_declaration | type_family_declaration | line_expression
expression ::= line_expression (nls line_expression)*
private line_expression ::= general_id+
scc_pragma ::= pragma
private general_id ::= QUASIQUOTE | q_name | symbol_reserved_op | reserved_id | LEFT_PAREN | RIGHT_PAREN | FLOAT |
SEMICOLON | LEFT_BRACKET | RIGHT_BRACKET | literal | LEFT_BRACE | RIGHT_BRACE |
COMMA | QUOTE | BACKQUOTE | fixity |
inlinelike_pragma | DIRECTIVE | scc_pragma
pragma | DIRECTIVE
dot_dot ::= DOT DOT
private symbol_reserved_op ::= dot_dot | COLON_COLON | EQUAL | BACKSLASH | VERTICAL_BAR | LEFT_ARROW | RIGHT_ARROW | AT | TILDE | DOUBLE_RIGHT_ARROW

5
src/main/scala/intellij/haskell/highlighter/HaskellHighlightingAnnotator.scala
View File

@ -14,10 +14,7 @@ class HaskellHighlightingAnnotator extends Annotator {
.setTextAttributes(HaskellSyntaxHighlighter.Keyword)
case psi: HaskellImportHiding => holder.createInfoAnnotation(psi, null)
.setTextAttributes(HaskellSyntaxHighlighter.Keyword)
case psi: HaskellFileHeaderPragma => psi.getGeneralPragmaContentList.forEach((t: HaskellGeneralPragmaContent) =>
holder.createInfoAnnotation(t, null).setTextAttributes(HaskellSyntaxHighlighter.PragmaContent))
case psi: HaskellOptionsGhcPragma =>
holder.createInfoAnnotation(psi, null).setTextAttributes(HaskellSyntaxHighlighter.PragmaContent)
case psi: HaskellPragma => holder.createInfoAnnotation(psi, null).setTextAttributes(HaskellSyntaxHighlighter.PragmaContent)
case psi: HaskellTypeSignature => holder.createInfoAnnotation(psi.getFirstChild, null)
.setTextAttributes(HaskellSyntaxHighlighter.FunctionName)
case psi: HaskellStringLiteralElementImpl => holder.createInfoAnnotation(psi, null)

4
src/main/scala/intellij/haskell/psi/HaskellElementFactory.scala
View File

@ -69,9 +69,9 @@ object HaskellElementFactory {
createElementFromText(project, declaration, HS_TOP_DECLARATION_LINE).map(_.asInstanceOf[HaskellTopDeclarationLine])
}
def createLanguagePragma(project: Project, languagePragma: String): HaskellFileHeaderPragma = {
def createLanguagePragma(project: Project, languagePragma: String): HaskellPragma = {
val haskellFile = createFileFromText(project, languagePragma)
PsiTreeUtil.findChildOfType(haskellFile, classOf[HaskellFileHeaderPragma])
PsiTreeUtil.findChildOfType(haskellFile, classOf[HaskellPragma])
}
def createLeafPsiElements(project: Project, code: String): util.Collection[LeafPsiElement] = {

4
src/main/scala/intellij/haskell/psi/HaskellPsiUtil.scala
View File

@ -37,8 +37,8 @@ object HaskellPsiUtil {
PsiTreeUtil.findChildrenOfType(psiFile.getOriginalFile, classOf[HaskellImportDeclaration]).asScala
}
def findLanguageExtensions(psiFile: PsiFile): Iterable[HaskellFileHeaderPragma] = {
PsiTreeUtil.findChildrenOfType(psiFile.getOriginalFile, classOf[HaskellFileHeaderPragma]).asScala
def findLanguageExtensions(psiFile: PsiFile): Iterable[HaskellPragma] = {
PsiTreeUtil.findChildrenOfType(psiFile.getOriginalFile, classOf[HaskellPragma]).asScala
}
def findNamedElement(psiElement: PsiElement): Option[HaskellNamedElement] = {