aposteriorist
diff --git a/‎src/python.grammar
Lines changed: 11 additions & 4 deletions b/‎src/python.grammar
Lines changed: 11 additions & 4 deletions
diff --git a/‎src/tokens.js
Lines changed: 15 additions & 0 deletions b/‎src/tokens.js
Lines changed: 15 additions & 0 deletions
diff --git a/‎test/statement.txt
Lines changed: 14 additions & 0 deletions b/‎test/statement.txt
Lines changed: 14 additions & 0 deletions
@@ -78,19 +78,19 @@ compoundStatement[@export] {
   DecoratedStatement { Decorator+ (ClassDefinition | FunctionDefinition) }
 }
 
-elseClause { kw<"else"> Body }
+elseClause { _else Body }
 
 IfStatement {
   kw<"if"> testNamed Body
-  (kw<"elif"> testNamed? Body)*
+  (_elif testNamed? Body)*
   elseClause?
 }
 
 TryStatement {
   kw<"try"> Body
-  (kw<"except"> (test ((kw<"as"> | ",") VariableName)?)? Body)*
+  (_except (test ((kw<"as"> | ",") VariableName)?)? Body)*
   elseClause?
-  (kw<"finally"> Body)?
+  (_finally Body)?
 }
 
 Body { ":" (simpleStatement | newline continueBody statement (continueBody statement)* (endBody | eof)) }
@@ -206,6 +206,13 @@ FormatReplacement { "{" (YieldExpression | commaSep<"*"? test>) FormatConversion
 
 @external tokens legacyPrint from "./tokens.js" { printKeyword[@name="print"] }
 
+@external tokens statementContinueKeyword from "./tokens" {
+  _else[@name="else"],
+  _elif[@name="elif"],
+  _except[@name="except"],
+  _finally[@name="finally"]
+}
+
 @tokens {
   CompareOp { "<" | ">" | $[<>=!] "=" | "<>" }
 
 
@@ -1,6 +1,7 @@
 import {ExternalTokenizer} from "lezer"
 import {
   newline as newlineToken, eof, newlineEmpty, newlineBracketed, continueBody, endBody,
+  _else, _elif, _except, _finally,
   ParenthesizedExpression, TupleExpression, ComprehensionExpression, ArrayExpression, ArrayComprehensionExpression,
   DictionaryExpression, DictionaryComprehensionExpression, SetExpression, SetComprehensionExpression,
   compoundStatement,
@@ -113,6 +114,20 @@ export const bodyContinue = new ExternalTokenizer((input, token, stack) => {
   token.accept(indentHere <= parentIndent ? endBody : continueBody, token.start)
 }, {contextual: true, fallback: true})
 
+let keywords = {else: _else, elif: _elif, except: _except, finally: _finally}
+
+// Matches else/elif/except/finally, but only when at same indentation
+// as their parent statement
+export const statementContinueKeyword = new ExternalTokenizer((input, token, stack) => {
+  let pos = token.start, next = input.get(token.start), m
+  if (next == 101 /* 'e' */ && (m = /^(?:else|elif|except)\b/.exec(input.read(pos, pos + 7))) ||
+      next == 102 /* 'f' */ && (m = /^finally\b/.exec(input.read(pos, pos + 8)))) {
+    let parent = stack.startOf(parentStatement)
+    let parentIndent = parent == null ? 0 : getIndent(input, parent)
+    if (getIndent(input, token.start) == parentIndent) token.accept(keywords[m[0]], pos + m[0].length)
+  }
+}, {contextual: true, fallback: true})
+
 export const legacyPrint = new ExternalTokenizer((input, token) => {
   let pos = token.start
   for (let print = "print", i = 0; i < print.length; i++, pos++)
 
@@ -296,3 +296,17 @@ pass
 ==>
 
 Script(FunctionDefinition(def,VariableName,ParamList,Body(⚠)), PassStatement(pass))
+
+# Nested else
+
+if a:
+  if b:
+    pass
+else:
+  pass
+
+==>
+
+Script(IfStatement(if, VariableName, Body(
+  IfStatement(if, VariableName, Body(PassStatement(pass)))),
+  else, Body(PassStatement(pass))))