robotframework 6.1rc1__zip → 7.0a1__zip

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/running/context.py

@@ -13,7 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 import inspect
 import asyncio
 from contextlib import contextmanager
@@ -43,9 +42,6 @@ class Asynchronous:
         return inspect.iscoroutine(obj) and not self._is_loop_running()
 
     def _is_loop_running(self):
-        # ensure 3.6 compatibility
-        if sys.version_info.minor == 6:
-            return asyncio._get_running_loop() is not None
         try:
             asyncio.get_running_loop()
         except RuntimeError:
@@ -150,7 +146,7 @@ class _ExecutionContext:
     def warn_on_invalid_private_call(self, handler):
         parent = self.user_keywords[-1] if self.user_keywords else None
         if not parent or parent.source != handler.source:
-            self.warn(f"Keyword '{handler.longname}' is private and should only "
+            self.warn(f"Keyword '{handler.full_name}' is private and should only "
                       f"be called by keywords in the same file.")
 
     @contextmanager
@@ -184,24 +180,24 @@ class _ExecutionContext:
 
     @property
     def allow_loop_control(self):
-        for step in reversed(self.steps):
+        for _, step in reversed(self.steps):
             if step.type == 'ITERATION':
                 return True
-            if step.type == 'KEYWORD' and step.libname != 'BuiltIn':
+            if step.type == 'KEYWORD' and step.owner != 'BuiltIn':
                 return False
         return False
 
-    def end_suite(self, suite):
+    def end_suite(self, data, result):
         for name in ['${PREV_TEST_NAME}',
                      '${PREV_TEST_STATUS}',
                      '${PREV_TEST_MESSAGE}']:
             self.variables.set_global(name, self.variables[name])
-        self.output.end_suite(suite)
-        self.namespace.end_suite(suite)
+        self.output.end_suite(data, result)
+        self.namespace.end_suite(data)
         EXECUTION_CONTEXTS.end_suite()
 
     def set_suite_variables(self, suite):
-        self.variables['${SUITE_NAME}'] = suite.longname
+        self.variables['${SUITE_NAME}'] = suite.full_name
         self.variables['${SUITE_SOURCE}'] = str(suite.source or '')
         self.variables['${SUITE_DOCUMENTATION}'] = suite.doc
         self.variables['${SUITE_METADATA}'] = suite.metadata.copy()
@@ -210,13 +206,14 @@ class _ExecutionContext:
         self.variables['${SUITE_STATUS}'] = status
         self.variables['${SUITE_MESSAGE}'] = message
 
-    def start_test(self, test):
-        self.test = test
-        self._add_timeout(test.timeout)
+    def start_test(self, data, result):
+        self.test = result
+        self._add_timeout(result.timeout)
         self.namespace.start_test()
-        self.variables.set_test('${TEST_NAME}', test.name)
-        self.variables.set_test('${TEST_DOCUMENTATION}', test.doc)
-        self.variables.set_test('@{TEST_TAGS}', list(test.tags))
+        self.variables.set_test('${TEST_NAME}', result.name)
+        self.variables.set_test('${TEST_DOCUMENTATION}', result.doc)
+        self.variables.set_test('@{TEST_TAGS}', list(result.tags))
+        self.output.start_test(data, result)
 
     def _add_timeout(self, timeout):
         if timeout:
@@ -236,19 +233,77 @@ class _ExecutionContext:
         self.variables.set_suite('${PREV_TEST_MESSAGE}', test.message)
         self.timeout_occurred = False
 
-    def start_keyword(self, keyword):
-        self.steps.append(keyword)
+    def start_body_item(self, data, result):
+        self.steps.append((data, result))
         if len(self.steps) > self._started_keywords_threshold:
             raise DataError('Maximum limit of started keywords and control '
                             'structures exceeded.')
-        self.output.start_keyword(keyword)
-
-    def end_keyword(self, keyword):
-        self.output.end_keyword(keyword)
+        output = self.output
+        if result.type in (result.ELSE, result.ITERATION):
+            method = {
+                result.IF_ELSE_ROOT: output.start_if_branch,
+                result.TRY_EXCEPT_ROOT: output.start_try_branch,
+                result.FOR: output.start_for_iteration,
+                result.WHILE: output.start_while_iteration,
+            }[result.parent.type]
+        else:
+            method = {
+                result.KEYWORD: output.start_keyword,
+                result.SETUP: output.start_keyword,
+                result.TEARDOWN: output.start_keyword,
+                result.FOR: output.start_for,
+                result.WHILE: output.start_while,
+                result.IF_ELSE_ROOT: output.start_if,
+                result.IF: output.start_if_branch,
+                result.ELSE: output.start_if_branch,
+                result.ELSE_IF: output.start_if_branch,
+                result.TRY_EXCEPT_ROOT: output.start_try,
+                result.TRY: output.start_try_branch,
+                result.EXCEPT: output.start_try_branch,
+                result.FINALLY: output.start_try_branch,
+                result.VAR: output.start_var,
+                result.BREAK: output.start_break,
+                result.CONTINUE: output.start_continue,
+                result.RETURN: output.start_return,
+                result.ERROR: output.start_error,
+            }[result.type]
+        method(data, result)
+
+    def end_body_item(self, data, result):
+        output = self.output
+        if result.type in (result.ELSE, result.ITERATION):
+            method = {
+                result.IF_ELSE_ROOT: output.end_if_branch,
+                result.TRY_EXCEPT_ROOT: output.end_try_branch,
+                result.FOR: output.end_for_iteration,
+                result.WHILE: output.end_while_iteration,
+            }[result.parent.type]
+        else:
+            method = {
+                result.KEYWORD: output.end_keyword,
+                result.SETUP: output.end_keyword,
+                result.TEARDOWN: output.end_keyword,
+                result.FOR: output.end_for,
+                result.WHILE: output.end_while,
+                result.IF_ELSE_ROOT: output.end_if,
+                result.IF: output.end_if_branch,
+                result.ELSE: output.end_if_branch,
+                result.ELSE_IF: output.end_if_branch,
+                result.TRY_EXCEPT_ROOT: output.end_try,
+                result.TRY: output.end_try_branch,
+                result.EXCEPT: output.end_try_branch,
+                result.FINALLY: output.end_try_branch,
+                result.VAR: output.end_var,
+                result.BREAK: output.end_break,
+                result.CONTINUE: output.end_continue,
+                result.RETURN: output.end_return,
+                result.ERROR: output.end_error,
+            }[result.type]
+        method(data, result)
         self.steps.pop()
 
-    def get_runner(self, name):
-        return self.namespace.get_runner(name)
+    def get_runner(self, name, recommend_on_failure=True):
+        return self.namespace.get_runner(name, recommend_on_failure)
 
     def trace(self, message):
         self.output.trace(message)

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/running/handlers.py

@@ -13,8 +13,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from copy import copy
 import inspect
+from copy import copy
 
 from robot.utils import (getdoc, getshortdoc, is_list_like, normpath, printable_name,
                          split_tags_from_doc, type_name)
@@ -91,15 +91,15 @@ class _RunnableHandler:
         return self._doc
 
     @property
-    def longname(self):
+    def full_name(self):
         return f'{self.library.name}.{self.name}'
 
     @property
-    def shortdoc(self):
+    def short_doc(self):
         return getshortdoc(self.doc)
 
     @property
-    def libname(self):
+    def owner(self):
         return self.library.name
 
     @property
@@ -137,7 +137,7 @@ class _PythonHandler(_RunnableHandler):
         super().__init__(library, handler_name, handler_method, getdoc(handler_method))
 
     def _parse_arguments(self, handler_method):
-        return PythonArgumentParser().parse(handler_method, self.longname)
+        return PythonArgumentParser().parse(handler_method, self.full_name)
 
     @property
     def source(self):
@@ -175,7 +175,7 @@ class _DynamicHandler(_RunnableHandler):
         self._source_info = None
 
     def _parse_arguments(self, handler_method):
-        spec = DynamicArgumentParser().parse(self._argspec, self.longname)
+        spec = DynamicArgumentParser().parse(self._argspec, self.full_name)
         if not self._supports_kwargs:
             name = self._run_keyword_method_name
             if spec.var_named:
@@ -285,7 +285,6 @@ class EmbeddedArgumentsHandler:
     supports_embedded_args = True
 
     def __init__(self, embedded, orig_handler):
-        self.arguments = ArgumentSpec()  # Show empty argument spec for Libdoc
         self.embedded = embedded
         self._orig_handler = orig_handler
 
@@ -307,15 +306,11 @@ class EmbeddedArgumentsHandler:
         return EmbeddedArgumentsRunner(self, name)
 
     def resolve_arguments(self, args, variables=None, languages=None):
-        argspec = self._orig_handler.arguments
-        if variables:
-            if argspec.var_positional:
-                args = variables.replace_list(args)
-            else:
-                args = [variables.replace_scalar(a) for a in args]
-            self.embedded.validate(args)
-        return argspec.convert(args, named={}, converters=self.library.converters,
-                               dry_run=not variables)
+        positional, named = self.arguments.resolve(args, variables,
+                                                   self.library.converters,
+                                                   languages=languages)
+        self.embedded.validate(positional)
+        return positional, named
 
     def __copy__(self):
         return EmbeddedArgumentsHandler(self.embedded, copy(self._orig_handler))

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/running/handlerstore.py

@@ -35,7 +35,7 @@ class HandlerStore:
         else:
             error = DataError('Keyword with same name defined multiple times.')
             self._normal[handler.name] = UserErrorHandler(error, handler.name,
-                                                          handler.libname)
+                                                          handler.owner)
             raise error
 
     def __iter__(self):

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/running/librarykeywordrunner.py

@@ -39,12 +39,8 @@ class LibraryKeywordRunner:
         return self._handler.library
 
     @property
-    def libname(self):
-        return self._handler.library.name
-
-    @property
-    def longname(self):
-        return '%s.%s' % (self.library.name, self.name)
+    def full_name(self):
+        return f'{self.library.name}.{self.name}'
 
     def run(self, kw, context, run=True):
         assignment = VariableAssignment(kw.assign)
@@ -58,9 +54,9 @@ class LibraryKeywordRunner:
 
     def _get_result(self, kw, assignment):
         handler = self._handler
-        return KeywordResult(kwname=self.name,
-                             libname=handler.libname,
-                             doc=handler.shortdoc,
+        return KeywordResult(name=self.name,
+                             owner=handler.owner,
+                             doc=handler.short_doc,
                              args=kw.args,
                              assign=tuple(assignment),
                              tags=handler.tags,
@@ -129,8 +125,7 @@ class LibraryKeywordRunner:
                                'BuiltIn.Set Library Search Order',
                                'BuiltIn.Set Tags',
                                'BuiltIn.Remove Tags')
-        return (handler.libname == 'Reserved' or
-                handler.longname in keywords_to_execute)
+        return handler.full_name in keywords_to_execute
 
 
 class EmbeddedArgumentsRunner(LibraryKeywordRunner):
@@ -140,17 +135,14 @@ class EmbeddedArgumentsRunner(LibraryKeywordRunner):
         self.embedded_args = handler.embedded.match(name).groups()
 
     def _run(self, context, args):
-        if args:
-            raise DataError("Positional arguments are not allowed when using "
-                            "embedded arguments.")
-        return super()._run(context, self.embedded_args)
+        return super()._run(context, self.embedded_args + args)
 
     def _dry_run(self, context, args):
-        return super()._dry_run(context, self.embedded_args)
+        return super()._dry_run(context, self.embedded_args + args)
 
     def _get_result(self, kw, assignment):
         result = super()._get_result(kw, assignment)
-        result.sourcename = self._handler.name
+        result.source_name = self._handler.name
         return result
 
 

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/running/model.py

@@ -34,22 +34,19 @@ __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#
 __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#listener-interface
 """
 
-import sys
 import warnings
 from pathlib import Path
-from typing import Any, Mapping, Sequence, TYPE_CHECKING, Union
-if sys.version_info >= (3, 8):
-    from typing import Literal
+from typing import Any, Literal, Mapping, Sequence, TYPE_CHECKING, Union
 
 from robot import model
 from robot.conf import RobotSettings
-from robot.errors import BreakLoop, ContinueLoop, DataError, ReturnFromKeyword
-from robot.model import (BodyItem, create_fixture, DataDict, Keywords, ModelObject,
-                         TestCases, TestSuites)
+from robot.errors import BreakLoop, ContinueLoop, DataError, ReturnFromKeyword, VariableError
+from robot.model import BodyItem, create_fixture, DataDict, ModelObject, TestSuites
 from robot.output import LOGGER, Output, pyloggingconf
 from robot.result import (Break as BreakResult, Continue as ContinueResult,
-                          Error as ErrorResult, Return as ReturnResult)
+                          Error as ErrorResult, Return as ReturnResult, Var as VarResult)
 from robot.utils import setter
+from robot.variables import VariableResolver
 
 from .bodyrunner import ForRunner, IfRunner, KeywordRunner, TryRunner, WhileRunner
 from .randomizer import Randomizer
@@ -64,8 +61,8 @@ BodyItemParent = Union['TestSuite', 'TestCase', 'UserKeyword', 'For', 'If', 'IfB
                        'Try', 'TryBranch', 'While', None]
 
 
-class Body(model.BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Return', 'Continue',
-                          'Break', 'model.Message', 'Error']):
+class Body(model.BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+                          'Continue', 'Break', 'model.Message', 'Error']):
     __slots__ = []
 
 
@@ -117,8 +114,8 @@ class For(model.For, WithSource):
     __slots__ = ['lineno', 'error']
     body_class = Body
 
-    def __init__(self, variables: Sequence[str] = (),
-                 flavor: "Literal['IN', 'IN RANGE', 'IN ENUMERATE', 'IN ZIP']" = 'IN',
+    def __init__(self, assign: Sequence[str] = (),
+                 flavor: Literal['IN', 'IN RANGE', 'IN ENUMERATE', 'IN ZIP'] = 'IN',
                  values: Sequence[str] = (),
                  start: 'str|None' = None,
                  mode: 'str|None' = None,
@@ -126,10 +123,17 @@ class For(model.For, WithSource):
                  parent: BodyItemParent = None,
                  lineno: 'int|None' = None,
                  error: 'str|None' = None):
-        super().__init__(variables, flavor, values, start, mode, fill, parent)
+        super().__init__(assign, flavor, values, start, mode, fill, parent)
         self.lineno = lineno
         self.error = error
 
+    @classmethod
+    def from_dict(cls, data: DataDict) -> 'For':
+        # RF 6.1 compatibility
+        if 'variables' in data:
+            data['assign'] = data.pop('variables')
+        return super().from_dict(data)
+
     def to_dict(self) -> DataDict:
         data = super().to_dict()
         if self.lineno:
@@ -219,12 +223,19 @@ class TryBranch(model.TryBranch, WithSource):
     def __init__(self, type: str = BodyItem.TRY,
                  patterns: Sequence[str] = (),
                  pattern_type: 'str|None' = None,
-                 variable: 'str|None' = None,
+                 assign: 'str|None' = None,
                  parent: BodyItemParent = None,
                  lineno: 'int|None' = None):
-        super().__init__(type, patterns, pattern_type, variable, parent)
+        super().__init__(type, patterns, pattern_type, assign, parent)
         self.lineno = lineno
 
+    @classmethod
+    def from_dict(cls, data: DataDict) -> 'TryBranch':
+        # RF 6.1 compatibility.
+        if 'variable' in data:
+            data['assign'] = data.pop('variable')
+        return super().from_dict(data)
+
     def to_dict(self) -> DataDict:
         data = super().to_dict()
         if self.lineno:
@@ -256,6 +267,59 @@ class Try(model.Try, WithSource):
         return data
 
 
+@Body.register
+class Var(model.Var, WithSource):
+    __slots__ = ['lineno', 'error']
+
+    def __init__(self, name: str = '',
+                 value: 'str|Sequence[str]' = (),
+                 scope: 'str|None' = None,
+                 separator: 'str|None' = None,
+                 parent: BodyItemParent = None,
+                 lineno: 'int|None' = None,
+                 error: 'str|None' = None):
+        super().__init__(name, value, scope, separator, parent)
+        self.lineno = lineno
+        self.error = error
+
+    def run(self, context, run=True, templated=False):
+        result = VarResult(self.name, self.value, self.scope, self.separator)
+        with StatusReporter(self, result, context, run):
+            if run:
+                if self.error:
+                    raise DataError(self.error, syntax=True)
+                if not context.dry_run:
+                    scope = self._get_scope(context.variables)
+                    setter = getattr(context.variables, f'set_{scope}')
+                    try:
+                        resolver = VariableResolver.from_variable(self)
+                        setter(self.name, resolver.resolve(context.variables))
+                    except DataError as err:
+                        raise VariableError(f"Setting variable '{self.name}' failed: {err}")
+
+    def _get_scope(self, variables):
+        if not self.scope:
+            return 'local'
+        try:
+            scope = variables.replace_string(self.scope)
+            if scope.upper() == 'TASK':
+                return 'test'
+            if scope.upper() in ('GLOBAL', 'SUITE', 'TEST', 'LOCAL'):
+                return scope.lower()
+            raise DataError(f"Value '{scope}' is not accepted. Valid values are "
+                            f"'GLOBAL', 'SUITE', 'TEST', 'TASK' and 'LOCAL'.")
+        except DataError as err:
+            raise DataError(f"Invalid VAR scope: {err}")
+
+    def to_dict(self) -> DataDict:
+        data = super().to_dict()
+        if self.lineno:
+            data['lineno'] = self.lineno
+        if self.error:
+            data['error'] = self.error
+        return data
+
+
 @Body.register
 class Return(model.Return, WithSource):
     __slots__ = ['lineno', 'error']
@@ -362,8 +426,7 @@ class Error(model.Error, WithSource):
         data = super().to_dict()
         if self.lineno:
             data['lineno'] = self.lineno
-        if self.error:
-            data['error'] = self.error
+        data['error'] = self.error
         return data
 
 
@@ -417,7 +480,7 @@ class TestSuite(model.TestSuite[Keyword, TestCase]):
                  doc: str = '',
                  metadata: 'Mapping[str, str]|None' = None,
                  source: 'Path|str|None' = None,
-                 rpa: 'bool|None' = None,
+                 rpa: 'bool|None' = False,
                  parent: 'TestSuite|None' = None):
         super().__init__(name, doc, metadata, source, rpa, parent)
         #: :class:`ResourceFile` instance containing imports, variables and
@@ -556,7 +619,7 @@ class TestSuite(model.TestSuite[Keyword, TestCase]):
         If such an option is used only once, it can be given also as a single
         string like ``variable='VAR:value'``.
 
-        Additionally listener option allows passing object directly instead of
+        Additionally, listener option allows passing object directly instead of
         listener name, e.g. ``run('tests.robot', listener=Listener())``.
 
         To capture stdout and/or stderr streams, pass open file objects in as
@@ -615,15 +678,17 @@ class TestSuite(model.TestSuite[Keyword, TestCase]):
 
 
 class Variable(ModelObject):
-    repr_args = ('name', 'value')
+    repr_args = ('name', 'value', 'separator')
 
     def __init__(self, name: str = '',
                  value: Sequence[str] = (),
+                 separator: 'str|None' = None,
                  parent: 'ResourceFile|None' = None,
                  lineno: 'int|None' = None,
                  error: 'str|None' = None):
         self.name = name
         self.value = tuple(value)
+        self.separator = separator
         self.parent = parent
         self.lineno = lineno
         self.error = error
@@ -632,7 +697,7 @@ class Variable(ModelObject):
     def source(self) -> 'Path|None':
         return self.parent.source if self.parent is not None else None
 
-    def report_invalid_syntax(self, message: str, level: str = 'ERROR'):
+    def report_error(self, message: str, level: str = 'ERROR'):
         source = self.source or '<unknown>'
         line = f' on line {self.lineno}' if self.lineno else ''
         LOGGER.write(f"Error in file '{source}'{line}: "
@@ -687,6 +752,50 @@ class ResourceFile(ModelObject):
     def keywords(self, keywords: Sequence['UserKeyword']) -> 'UserKeywords':
         return UserKeywords(self, keywords)
 
+    @classmethod
+    def from_file_system(cls, path: 'Path|str', **config) -> 'ResourceFile':
+        """Create a :class:`ResourceFile` object based on the give ``path``.
+
+        :param path: File path where to read the data from.
+        :param config: Configuration parameters for :class:`~.builders.ResourceFileBuilder`
+            class that is used internally for building the suite.
+
+        New in Robot Framework 6.1. See also :meth:`from_string` and :meth:`from_model`.
+        """
+        from .builder import ResourceFileBuilder
+        return ResourceFileBuilder(**config).build(path)
+
+    @classmethod
+    def from_string(cls, string: str, **config) -> 'ResourceFile':
+        """Create a :class:`ResourceFile` object based on the given ``string``.
+
+        :param string: String to create the resource file from.
+        :param config: Configuration parameters for
+             :func:`~robot.parsing.parser.parser.get_resource_model` used internally.
+
+        New in Robot Framework 6.1. See also :meth:`from_file_system` and
+        :meth:`from_model`.
+        """
+        from robot.parsing import get_resource_model
+        model = get_resource_model(string, data_only=True, **config)
+        return cls.from_model(model)
+
+    @classmethod
+    def from_model(cls, model: 'File') -> 'ResourceFile':
+        """Create a :class:`ResourceFile` object based on the given ``model``.
+
+        :param model: Model to create the suite from.
+
+        The model can be created by using the
+        :func:`~robot.parsing.parser.parser.get_resource_model` function and possibly
+        modified by other tooling in the :mod:`robot.parsing` module.
+
+        New in Robot Framework 6.1. See also :meth:`from_file_system` and
+        :meth:`from_string`.
+        """
+        from .builder import RobotParser
+        return RobotParser().parse_resource_model(model)
+
     def to_dict(self) -> DataDict:
         data = {}
         if self._source:
@@ -706,7 +815,7 @@ class UserKeyword(ModelObject):
     repr_args = ('name', 'args')
     fixture_class = Keyword
     __slots__ = ['name', 'args', 'doc', 'return_', 'timeout', 'lineno', 'parent',
-                 'error', '_teardown']
+                 'error', '_setup', '_teardown']
 
     def __init__(self, name: str = '',
                  args: Sequence[str] = (),
@@ -727,6 +836,7 @@ class UserKeyword(ModelObject):
         self.parent = parent
         self.error = error
         self.body = []
+        self._setup = None
         self._teardown = None
 
     @setter
@@ -734,24 +844,32 @@ class UserKeyword(ModelObject):
         return Body(self, body)
 
     @property
-    def keywords(self) -> Keywords:
-        """Deprecated since Robot Framework 4.0.
+    def setup(self) -> Keyword:
+        """User keyword setup as a :class:`Keyword` object.
 
-        Use :attr:`body` or :attr:`teardown` instead.
+        New in Robot Framework 7.0.
         """
-        kws = list(self.body)
-        if self.teardown:
-            kws.append(self.teardown)
-        return Keywords(self, kws)
+        if self._setup is None:
+            self.setup = None
+        return self._setup
+
+    @setup.setter
+    def setup(self, setup: 'Keyword|DataDict|None'):
+        self._setup = create_fixture(self.fixture_class, setup, self, Keyword.SETUP)
 
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
+    @property
+    def has_setup(self) -> bool:
+        """Check does a keyword have a setup without creating a setup object.
+
+        See :attr:`has_teardown` for more information. New in Robot Framework 7.0.
+        """
+        return bool(self._setup)
 
     @property
     def teardown(self) -> Keyword:
+        """User keyword teardown as a :class:`Keyword` object."""
         if self._teardown is None:
-            self._teardown = create_fixture(self.fixture_class, None, self, Keyword.TEARDOWN)
+            self.teardown = None
         return self._teardown
 
     @teardown.setter
@@ -762,7 +880,7 @@ class UserKeyword(ModelObject):
     def has_teardown(self) -> bool:
         """Check does a keyword have a teardown without creating a teardown object.
 
-        A difference between using ``if uk.has_teardown:`` and ``if uk.teardown:``
+        A difference between using ``if kw.has_teardown:`` and ``if kw.teardown:``
         is that accessing the :attr:`teardown` attribute creates a :class:`Keyword`
         object representing the teardown even when the user keyword actually does
         not have one. This can have an effect on memory usage.
@@ -790,6 +908,8 @@ class UserKeyword(ModelObject):
                             ('error', self.error)]:
             if value:
                 data[name] = value
+        if self.has_setup:
+            data['setup'] = self.setup.to_dict()
         data['body'] = self.body.to_dicts()
         if self.has_teardown:
             data['teardown'] = self.teardown.to_dict()
@@ -802,7 +922,7 @@ class Import(ModelObject):
     RESOURCE = 'RESOURCE'
     VARIABLES = 'VARIABLES'
 
-    def __init__(self, type: "Literal['LIBRARY', 'RESOURCE', 'VARIABLES']",
+    def __init__(self, type: Literal['LIBRARY', 'RESOURCE', 'VARIABLES'],
                  name: str,
                  args: Sequence[str] = (),
                  alias: 'str|None' = None,
@@ -836,7 +956,7 @@ class Import(ModelObject):
                 self.RESOURCE: resource,
                 self.VARIABLES: variables}[self.type]
 
-    def report_invalid_syntax(self, message: str, level: str = 'ERROR'):
+    def report_error(self, message: str, level: str = 'ERROR'):
         source = self.source or '<unknown>'
         line = f' on line {self.lineno}' if self.lineno else ''
         LOGGER.write(f"Error in file '{source}'{line}: {message}", level)