Optimize code

 * Ensure strings functions always return something
 * Warns if the user forgets to return something
 * Removes dead code in the AST (-O2)

Author: boriel

src/api/errmsg.py

@@ -176,6 +176,16 @@ def warning_fastcall_with_N_parameters(lineno: int, kind: str, id_: str, num_par
 def warning_func_is_never_called(lineno: int, func_name: str, fname: Optional[str] = None):
     warning(lineno, f"Function '{func_name}' is never called and has been ignored", fname=fname)
 
+
+@register_warning('180')
+def warning_unreachable_code(lineno: int, fname: Optional[str] = None):
+    warning(lineno, "Unreachable code", fname=fname)
+
+
+@register_warning('190')
+def warning_function_should_return_a_value(lineno: int, func_name: str, fname: Optional[str] = None):
+    warning(lineno, f"Function '{func_name}' should return a value", fname=fname)
+
 # endregion
 
 # region [Syntax Errors]

src/api/optimize.py

@@ -4,6 +4,7 @@
 import types
 
 from typing import NamedTuple
+from typing import Optional
 from typing import Set
 
 import src.api.global_ as gl
@@ -156,6 +157,12 @@ def visit_FUNCTION(self, node):
             yield node
         else:
             node.visited = True
+            if node.body.token == 'BLOCK' and (not node.body or node.body[-1].token != 'RETURN'):
+                # String functions must *ALWAYS* return a value.
+                # Put a sentinel ("dummy") return "" sentence that will be removed if other is detected
+                lineno = node.lineno if not node.body else node.body[-1].lineno
+                errmsg.warning_function_should_return_a_value(lineno, node.name, node.filename)
+                node.body.append(symbols.ASM('\nld hl, 0\n', lineno, node.filename, is_sentinel=True))
             yield (yield self.generic_visit(node))
 
     def visit_LET(self, node):
@@ -195,9 +202,41 @@ def visit_UNARY(self, node):
             yield (yield self.generic_visit(node))
 
     def visit_BLOCK(self, node):
+        warning_emitted = False
+        i = 0
+        while i < len(node):
+            sentence = node[i]
+            if chk.is_ender(sentence):
+                j = i + 1
+                while j < len(node) - 1:
+                    if chk.is_LABEL(node[j]):
+                        break
+
+                    if node[j].token == 'FUNCDECL':
+                        j += 1
+                        continue
+
+                    if node[j].is_sentinel:  # "Sentinel" instructions can be freely removed
+                        node.pop(j)
+                        continue
+
+                    if node[j].token == 'ASM':
+                        break  # User's ASM must always be left there
+
+                    if not warning_emitted and self.O_LEVEL > 0:
+                        warning_emitted = True
+                        errmsg.warning_unreachable_code(lineno=node[j].lineno, fname=node[j].filename)
+
+                        if self.O_LEVEL < 2:
+                            break
+
+                    node.pop(j)
+            i += 1
+
         if self.O_LEVEL >= 1 and chk.is_null(node):
             yield self.NOP
             return
+
         yield (yield self.generic_visit(node))
 
     def visit_IF(self, node):
@@ -309,12 +348,12 @@ class VarDependency(NamedTuple):
 
 
 class VariableVisitor(GenericVisitor):
-    _original_variable = None
+    _original_variable: Optional[symbols.VAR] = None
     _parent_variable = None
-    _visited = set()
+    _visited: Set[symbols.SYMBOL] = set()
 
     @staticmethod
-    def generic_visit(node):
+    def generic_visit(node: symbols.SYMBOL):  # type: ignore
         if node not in VariableVisitor._visited:
             VariableVisitor._visited.add(node)
             for i in range(len(node.children)):
@@ -332,7 +371,7 @@ def has_circular_dependency(self, var_dependency: VarDependency) -> bool:
         return False
 
     def get_var_dependencies(self, var_entry: symbols.VAR):
-        visited: Set[symbols.Var] = set()
+        visited: Set[symbols.VAR] = set()
         result = set()
 
         def visit_var(entry):

src/libzxbc/zxbparser.py

@@ -239,16 +239,16 @@ def make_strslice(lineno, s, lower, upper):
     return symbols.STRSLICE.make_node(lineno, s, lower, upper)
 
 
-def make_sentence(lineno: int, sentence, *args, **kwargs):
+def make_sentence(lineno: int, sentence: str, *args, sentinel=False):
     """ Wrapper: returns a Sentence node
     """
-    return symbols.SENTENCE(lineno, gl.FILENAME, *([sentence] + list(args)), **kwargs)
+    return symbols.SENTENCE(lineno, gl.FILENAME, sentence, *args, is_sentinel=sentinel)
 
 
-def make_asm_sentence(asm, lineno):
+def make_asm_sentence(asm: str, lineno: int, sentinel: bool = False):
     """ Creates a node for an ASM inline sentence
     """
-    return symbols.ASM(asm, lineno)
+    return symbols.ASM(asm, lineno, gl.FILENAME, is_sentinel=sentinel)
 
 
 def make_block(*args):
@@ -513,7 +513,7 @@ def p_start(p):
         sys.exit(1)
 
     ast = p[0] = p[1]
-    __end = make_sentence(p.lexer.lineno, 'END', make_number(0, lineno=p.lexer.lineno))
+    __end = make_sentence(p.lexer.lineno, 'END', make_number(0, lineno=p.lexer.lineno), sentinel=True)
 
     if not is_null(ast):
         ast.appendChild(__end)
@@ -2054,7 +2054,7 @@ def p_return(p):
         return
 
     if FUNCTION_LEVEL[-1].kind != KIND.sub:
-        error(p.lineno(1), 'Syntax Error: Functions must RETURN a value, or use EXIT FUNCTION instead.')
+        error(p.lineno(1), 'Syntax Error: Function must RETURN a value.')
         p[0] = None
         return
 
@@ -3129,7 +3129,7 @@ def p_function_body(p):
         error(p.lineno(i), "Unexpected token 'END %s'. Should be 'END %s'" % (b.upper(), a.upper()))
         p[0] = None
     else:
-        p[0] = None if p[1] == 'END' else p[1]
+        p[0] = make_block() if p[1] == 'END' else p[1]
 
 
 def p_type_def_empty(p):

tests/functional/ltee4.asm

@@ -59,6 +59,9 @@ _hsGetName:
 	push ix
 	ld ix, 0
 	add ix, sp
+#line 4
+		ld hl, 0
+#line 5
 _hsGetName__leave:
 	ld sp, ix
 	pop ix