robotframework 6.1.1__zip → 7.0a1__zip

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/running/namespace.py

@@ -35,18 +35,18 @@ IMPORTER = Importer()
 
 
 class Namespace:
-    _default_libraries = ('BuiltIn', 'Reserved', 'Easter')
+    _default_libraries = ('BuiltIn', 'Easter')
     _library_import_by_path_ends = ('.py', '/', os.sep)
     _variables_import_by_path_ends = _library_import_by_path_ends + ('.yaml', '.yml') + ('.json',)
 
     def __init__(self, variables, suite, resource, languages):
-        LOGGER.info(f"Initializing namespace for suite '{suite.longname}'.")
+        LOGGER.info(f"Initializing namespace for suite '{suite.full_name}'.")
         self.variables = variables
         self.languages = languages
         self._imports = resource.imports
         self._kw_store = KeywordStore(resource, languages)
         self._imported_variable_files = ImportCache()
-        self._suite_name = suite.longname
+        self._suite_name = suite.full_name
         self._running_test = False
 
     @property
@@ -68,7 +68,7 @@ class Namespace:
                     raise DataError(f'{item.setting_name} setting requires value.')
                 self._import(item)
             except DataError as err:
-                item.report_invalid_syntax(err.message)
+                item.report_error(err.message)
 
     def _import(self, import_setting):
         action = import_setting.select(self._import_library,
@@ -84,7 +84,7 @@ class Namespace:
         self._validate_not_importing_init_file(path)
         if overwrite or path not in self._kw_store.resources:
             resource = IMPORTER.import_resource(path, self.languages)
-            self.variables.set_from_variable_table(resource.variables, overwrite)
+            self.variables.set_from_variable_section(resource.variables, overwrite)
             user_library = UserLibrary(resource)
             self._kw_store.resources[path] = user_library
             self._handle_imports(resource.imports)
@@ -203,15 +203,15 @@ class Namespace:
     def end_user_keyword(self):
         self.variables.end_keyword()
 
-    def get_library_instance(self, libname):
-        return self._kw_store.get_library(libname).get_instance()
+    def get_library_instance(self, name):
+        return self._kw_store.get_library(name).get_instance()
 
     def get_library_instances(self):
         return dict((name, lib.get_instance())
                     for name, lib in self._kw_store.libraries.items())
 
-    def reload_library(self, libname_or_instance):
-        library = self._kw_store.get_library(libname_or_instance)
+    def reload_library(self, name_or_instance):
+        library = self._kw_store.get_library(name_or_instance)
         library.reload()
         return library
 
@@ -328,7 +328,7 @@ class KeywordStore:
         if caller and runner.source != caller.source:
             if self._exists_in_resource_file(name, caller.source):
                 message = (
-                    f"Keyword '{caller.longname}' called keyword '{name}' that exists "
+                    f"Keyword '{caller.full_name}' called keyword '{name}' that exists "
                     f"both in the same resource file as the caller and in the suite "
                     f"file using that resource. The keyword in the suite file is used "
                     f"now, but this will change in Robot Framework 7.0."
@@ -409,8 +409,8 @@ class KeywordStore:
         return matches or handlers
 
     def _filter_based_on_search_order(self, handlers):
-        for libname in self.search_order:
-            matches = [hand for hand in handlers if eq(libname, hand.libname)]
+        for name in self.search_order:
+            matches = [hand for hand in handlers if eq(name, hand.owner)]
             if matches:
                 return matches
         return handlers
@@ -441,7 +441,7 @@ class KeywordStore:
             f"'{custom.library.orig_name}'{custom_with_name} and a standard library "
             f"'{standard.library.orig_name}'{standard_with_name}. The custom keyword "
             f"is used. To select explicitly, and to get rid of this warning, use "
-            f"either '{custom.longname}' or '{standard.longname}'.", level='WARN'
+            f"either '{custom.full_name}' or '{standard.full_name}'.", level='WARN'
         )
 
     def _get_explicit_runner(self, name):
@@ -475,7 +475,7 @@ class KeywordStore:
             error = f"Multiple keywords with name '{name}' found"
             if implicit:
                 error += ". Give the full name of the keyword you want to use"
-        names = sorted(hand.longname for hand in handlers)
+        names = sorted(hand.full_name for hand in handlers)
         raise KeywordError('\n    '.join([error+':'] + names))
 
 
@@ -511,9 +511,8 @@ class KeywordRecommendationFinder:
         handlers = [('', printable_name(handler.name, True))
                     for handler in self.user_keywords.handlers]
         for library in chain(self.libraries.values(), self.resources.values()):
-            if library.name != 'Reserved':
-                handlers.extend(
-                    ((library.name or '',
-                      printable_name(handler.name, code_style=True))
-                     for handler in library.handlers))
+            handlers.extend(
+                ((library.name or '',
+                  printable_name(handler.name, code_style=True))
+                 for handler in library.handlers))
         return sorted(handlers)

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/running/statusreporter.py

@@ -13,11 +13,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.errors import (ExecutionFailed, ExecutionStatus, DataError,
-                          HandlerExecutionFailed)
-from robot.utils import ErrorDetails, get_timestamp
+from datetime import datetime
 
-from .modelcombiner import ModelCombiner
+from robot.errors import (BreakLoop, ContinueLoop, DataError, ExecutionFailed,
+                          ExecutionStatus, HandlerExecutionFailed, ReturnFromKeyword)
+from robot.utils import ErrorDetails
 
 
 class StatusReporter:
@@ -38,16 +38,17 @@ class StatusReporter:
         context = self.context
         result = self.result
         self.initial_test_status = context.test.status if context.test else None
-        if not result.starttime:
-            result.starttime = get_timestamp()
-        context.start_keyword(ModelCombiner(self.data, result))
-        self._warn_if_deprecated(result.doc, result.name)
+        if not result.start_time:
+            result.start_time = datetime.now()
+        context.start_body_item(self.data, result)
+        if result.type in result.KEYWORD_TYPES:
+            self._warn_if_deprecated(result.doc, result.full_name)
         return self
 
     def _warn_if_deprecated(self, doc, name):
         if doc.startswith('*DEPRECATED') and '*' in doc[1:]:
             message = ' ' + doc.split('*', 2)[-1].strip()
-            self.context.warn("Keyword '%s' is deprecated.%s" % (name, message))
+            self.context.warn(f"Keyword '{name}' is deprecated.{message}")
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         context = self.context
@@ -57,12 +58,12 @@ class StatusReporter:
             result.status = self.pass_status
         else:
             result.status = failure.status
-            if result.type == result.TEARDOWN:
+            if not isinstance(failure, (BreakLoop, ContinueLoop, ReturnFromKeyword)):
                 result.message = failure.message
         if self.initial_test_status == 'PASS':
             context.test.status = result.status
-        result.endtime = get_timestamp()
-        context.end_keyword(ModelCombiner(self.data, result))
+        result.elapsed_time = datetime.now() - result.start_time
+        context.end_body_item(self.data, result)
         if failure is not exc_val and not self.suppress:
             raise failure
         return self.suppress

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/running/suiterunner.py

@@ -13,15 +13,16 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from datetime import datetime
+
 from robot.errors import ExecutionFailed, ExecutionStatus, DataError, PassExecution
 from robot.model import SuiteVisitor, TagPatterns
 from robot.result import TestSuite, Result
-from robot.utils import get_timestamp, is_list_like, NormalizedDict, test_or_task
+from robot.utils import is_list_like, NormalizedDict, test_or_task
 from robot.variables import VariableScopes
 
 from .bodyrunner import BodyRunner, KeywordRunner
 from .context import EXECUTION_CONTEXTS
-from .modelcombiner import ModelCombiner
 from .namespace import Namespace
 from .status import SuiteStatus, TestStatus
 from .timeouts import TestTimeout
@@ -46,7 +47,7 @@ class SuiteRunner(SuiteVisitor):
     def start_suite(self, suite):
         if suite.name in self._executed[-1] and suite.parent.source:
             self._output.warn(f"Multiple suites with name '{suite.name}' executed in "
-                              f"suite '{suite.parent.longname}'.")
+                              f"suite '{suite.parent.full_name}'.")
         self._executed[-1][suite.name] = True
         self._executed.append(NormalizedDict(ignore='_'))
         self._output.library_listeners.new_suite_scope()
@@ -54,7 +55,7 @@ class SuiteRunner(SuiteVisitor):
                            name=suite.name,
                            doc=suite.doc,
                            metadata=suite.metadata,
-                           starttime=get_timestamp(),
+                           start_time=datetime.now(),
                            rpa=self._settings.rpa)
         if not self.result:
             self.result = Result(root_suite=result, rpa=self._settings.rpa)
@@ -69,7 +70,7 @@ class SuiteRunner(SuiteVisitor):
                                          self._settings.skip_teardown_on_exit)
         ns = Namespace(self._variables, result, suite.resource, self._settings.languages)
         ns.start_suite()
-        ns.variables.set_from_variable_table(suite.resource.variables)
+        ns.variables.set_from_variable_section(suite.resource.variables)
         EXECUTION_CONTEXTS.start_suite(result, ns, self._output,
                                        self._settings.dry_run)
         self._context.set_suite_variables(result)
@@ -80,10 +81,7 @@ class SuiteRunner(SuiteVisitor):
         result.metadata = [(self._resolve_setting(n), self._resolve_setting(v))
                            for n, v in result.metadata.items()]
         self._context.set_suite_variables(result)
-        self._output.start_suite(ModelCombiner(suite, result,
-                                               tests=suite.tests,
-                                               suites=suite.suites,
-                                               test_count=suite.test_count))
+        self._output.start_suite(suite, result)
         self._output.register_error_listener(self._suite_status.error_occurred)
         self._run_setup(suite, self._suite_status, run=self._any_test_run(suite))
 
@@ -113,9 +111,9 @@ class SuiteRunner(SuiteVisitor):
                     self._suite.suite_teardown_skipped(str(failure))
                 else:
                     self._suite.suite_teardown_failed(str(failure))
-        self._suite.endtime = get_timestamp()
+        self._suite.end_time = datetime.now()
         self._suite.message = self._suite_status.message
-        self._context.end_suite(ModelCombiner(suite, self._suite))
+        self._context.end_suite(suite, self._suite)
         self._executed.pop()
         self._suite = self._suite.parent
         self._suite_status = self._suite_status.parent
@@ -128,16 +126,15 @@ class SuiteRunner(SuiteVisitor):
         if test.name in self._executed[-1]:
             self._output.warn(
                 test_or_task(f"Multiple {{test}}s with name '{test.name}' executed in "
-                             f"suite '{test.parent.longname}'.", settings.rpa))
+                             f"suite '{test.parent.full_name}'.", settings.rpa))
         self._executed[-1][test.name] = True
         result = self._suite.tests.create(self._resolve_setting(test.name),
                                           self._resolve_setting(test.doc),
                                           self._resolve_setting(test.tags),
                                           self._get_timeout(test),
                                           test.lineno,
-                                          starttime=get_timestamp())
-        self._context.start_test(result)
-        self._output.start_test(ModelCombiner(test, result))
+                                          start_time=datetime.now())
+        self._context.start_test(test, result)
         status = TestStatus(self._suite_status, result, settings.skip_on_failure,
                             settings.rpa)
         if status.exit:
@@ -187,9 +184,10 @@ class SuiteRunner(SuiteVisitor):
         if status.skip_on_failure_after_tag_changes:
             result.message = status.message or result.message
         result.status = status.status
-        result.endtime = get_timestamp()
+        result.end_time = datetime.now()
         failed_before_listeners = result.failed
-        self._output.end_test(ModelCombiner(test, result))
+        # TODO: can this be removed to context
+        self._output.end_test(test, result)
         if result.failed and not failed_before_listeners:
             status.failure_occurred()
         self._context.end_test(result)

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/running/testlibraries.py

@@ -13,9 +13,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from functools import partial
 import inspect
 import os
+from functools import cached_property, partial
 
 from robot.errors import DataError
 from robot.libraries import STDLIBS
@@ -134,10 +134,9 @@ class _BaseTestLibrary:
     def report_error(self, message, details=None, level='ERROR',
                      details_level='INFO'):
         prefix = 'Error in' if level in ('ERROR', 'WARN') else 'In'
-        self.logger.write("%s library '%s': %s" % (prefix, self.name, message),
-                          level)
+        self.logger.write(f"{prefix} library '{self.name}': {message}", level)
         if details:
-            self.logger.write('Details:\n%s' % details, details_level)
+            self.logger.write(f'Details:\n{details}', details_level)
 
     def _get_version(self, libcode):
         return self._get_attr(libcode, 'ROBOT_LIBRARY_VERSION') \
@@ -209,8 +208,8 @@ class _BaseTestLibrary:
             except DataError as err:
                 self.has_listener = False
                 # Error should have information about suite where the
-                # problem occurred but we don't have such info here.
-                self.report_error("Registering listeners failed: %s" % err)
+                # problem occurred, but we don't have such info here.
+                self.report_error(f"Registering listeners failed: {err}")
 
     def unregister_listeners(self, close=False):
         if self.has_listener:
@@ -231,16 +230,16 @@ class _BaseTestLibrary:
         except Exception:
             message, details = get_error_details()
             name = getattr(listener, '__name__', None) or type_name(listener)
-            self.report_error("Calling method '%s' of listener '%s' failed: %s"
-                              % (method.__name__, name, message), details)
+            self.report_error(f"Calling method '{method.__name__}' of listener "
+                              f"'{name}' failed: {message}", details)
 
     def _create_handlers(self, libcode):
         try:
             names = self._get_handler_names(libcode)
         except Exception:
             message, details = get_error_details()
-            raise DataError("Getting keyword names from library '%s' failed: %s"
-                            % (self.name, message), details)
+            raise DataError(f"Getting keyword names from library '{self.name}' "
+                            f"failed: {message}", details)
         for name in names:
             method = self._try_to_get_handler_method(libcode, name)
             if method:
@@ -251,15 +250,12 @@ class _BaseTestLibrary:
                     except DataError as err:
                         self._adding_keyword_failed(handler.name, err)
                     else:
-                        self.logger.debug("Created keyword '%s'" % handler.name)
+                        self.logger.debug(f"Created keyword '{handler.name}'.")
 
     def _get_handler_names(self, libcode):
         def has_robot_name(name):
-            try:
-                handler = self._get_handler_method(libcode, name)
-            except DataError:
-                return False
-            return hasattr(handler, 'robot_name')
+            candidate = inspect.getattr_static(libcode, name)
+            return hasattr(candidate, 'robot_name')
 
         auto_keywords = getattr(libcode, 'ROBOT_AUTO_KEYWORDS', True)
         if auto_keywords:
@@ -277,7 +273,7 @@ class _BaseTestLibrary:
 
     def _adding_keyword_failed(self, name, error, level='ERROR'):
         self.report_error(
-            "Adding keyword '%s' failed: %s" % (name, error.message),
+            f"Adding keyword '{name}' failed: {error}",
             error.details,
             level=level,
             details_level='DEBUG'
@@ -317,41 +313,38 @@ class _BaseTestLibrary:
     def _get_possible_embedded_args_handler(self, handler):
         embedded = EmbeddedArguments.from_name(handler.name)
         if embedded:
-            self._validate_embedded_count(embedded, handler.arguments)
+            if len(embedded.args) > handler.arguments.maxargs:
+                raise DataError(f'Keyword must accept at least as many positional '
+                                f'arguments as it has embedded arguments.')
+            handler.arguments.embedded = embedded.args
             return EmbeddedArgumentsHandler(embedded, handler), True
         return handler, False
 
-    def _validate_embedded_count(self, embedded, arguments):
-        if not (arguments.minargs <= len(embedded.args) <= arguments.maxargs):
-            raise DataError('Embedded argument count does not match number of '
-                            'accepted arguments.')
-
     def _raise_creating_instance_failed(self):
-        msg, details = get_error_details()
+        message, details = get_error_details()
         if self.positional_args or self.named_args:
-            args = self.positional_args + ['%s=%s' % item for item in self.named_args]
-            args_text = 'arguments %s' % seq2str2(args)
+            args = self.positional_args + [f'{n}={v}' for n, v in self.named_args]
+            args_text = f'arguments {seq2str2(args)}'
         else:
             args_text = 'no arguments'
-        raise DataError("Initializing library '%s' with %s failed: %s\n%s"
-                        % (self.name, args_text, msg, details))
+        raise DataError(f"Initializing library '{self.name}' with {args_text} failed: "
+                        f"{message}\n{details}")
 
 
 class _ClassLibrary(_BaseTestLibrary):
 
     def _get_handler_method(self, libinst, name):
-        for item in (libinst,) + inspect.getmro(libinst.__class__):
-            # `isroutine` is used before `getattr` to avoid calling properties.
-            if (name in getattr(item, '__dict__', ())
-                    and inspect.isroutine(item.__dict__[name])):
-                try:
-                    method = getattr(libinst, name)
-                except Exception:
-                    message, traceback = get_error_details()
-                    raise DataError(f'Getting handler method failed: {message}',
-                                    traceback)
-                return self._validate_handler_method(method)
-        raise DataError('Not a method or function.')
+        candidate = inspect.getattr_static(libinst, name)
+        if isinstance(candidate, classmethod):
+            candidate = candidate.__func__
+        if isinstance(candidate, cached_property) or not inspect.isroutine(candidate):
+            raise DataError('Not a method or function.')
+        try:
+            method = getattr(libinst, name)
+        except Exception:
+            message, details = get_error_details()
+            raise DataError(f'Getting handler method failed: {message}', details)
+        return self._validate_handler_method(method)
 
 
 class _ModuleLibrary(_BaseTestLibrary):

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/running/usererrorhandler.py

@@ -30,17 +30,17 @@ class UserErrorHandler:
     """
     supports_embedded_arguments = False
 
-    def __init__(self, error, name, libname=None, source=None, lineno=None):
+    def __init__(self, error, name, owner=None, source=None, lineno=None):
         """
         :param robot.errors.DataError error: Occurred error.
         :param str name: Name of the affected keyword.
-        :param str libname: Name of the affected library or resource.
+        :param str owner: Name of the affected library or resource.
         :param str source: Path to the source file.
         :param int lineno: Line number of the failing keyword.
         """
         self.error = error
         self.name = name
-        self.libname = libname
+        self.owner = owner
         self.source = source
         self.lineno = lineno
         self.arguments = ArgumentSpec()
@@ -48,23 +48,23 @@ class UserErrorHandler:
         self.tags = Tags()
 
     @property
-    def longname(self):
-        return f'{self.libname}.{self.name}' if self.libname else self.name
+    def full_name(self):
+        return f'{self.owner}.{self.name}' if self.owner else self.name
 
     @property
     def doc(self):
         return f'*Creating keyword failed:* {self.error}'
 
     @property
-    def shortdoc(self):
+    def short_doc(self):
         return self.doc.splitlines()[0]
 
     def create_runner(self, name, languages=None):
         return self
 
     def run(self, kw, context, run=True):
-        result = KeywordResult(kwname=self.name,
-                               libname=self.libname,
+        result = KeywordResult(name=self.name,
+                               owner=self.owner,
                                args=kw.args,
                                assign=tuple(VariableAssignment(kw.assign)),
                                type=kw.type)

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/running/userkeyword.py

@@ -49,6 +49,10 @@ class UserLibrary:
     def _create_handler(self, kw):
         if kw.error:
             raise DataError(kw.error)
+        if not kw.body and not kw.return_:
+            raise DataError('User keyword cannot be empty.')
+        if not kw.name:
+            raise DataError('User keyword name cannot be empty.')
         embedded = EmbeddedArguments.from_name(kw.name)
         if not embedded:
             return UserKeywordHandler(kw, self.name)
@@ -67,26 +71,27 @@ class UserLibrary:
 class UserKeywordHandler:
     supports_embedded_args = False
 
-    def __init__(self, keyword, libname):
+    def __init__(self, keyword, owner):
         self.name = keyword.name
-        self.libname = libname
+        self.owner = owner
         self.doc = keyword.doc
         self.source = keyword.source
         self.lineno = keyword.lineno
         self.tags = keyword.tags
         self.arguments = UserKeywordArgumentParser().parse(tuple(keyword.args),
-                                                           self.longname)
+                                                           self.full_name)
         self.timeout = keyword.timeout
         self.body = keyword.body
         self.return_value = tuple(keyword.return_)
+        self.setup = keyword.setup if keyword.has_setup else None
         self.teardown = keyword.teardown if keyword.has_teardown else None
 
     @property
-    def longname(self):
-        return '%s.%s' % (self.libname, self.name) if self.libname else self.name
+    def full_name(self):
+        return f'{self.owner}.{self.name}' if self.owner else self.name
 
     @property
-    def shortdoc(self):
+    def short_doc(self):
         return getshortdoc(self.doc)
 
     @property
@@ -100,8 +105,8 @@ class UserKeywordHandler:
 class EmbeddedArgumentsHandler(UserKeywordHandler):
     supports_embedded_args = True
 
-    def __init__(self, keyword, libname, embedded):
-        super().__init__(keyword, libname)
+    def __init__(self, keyword, owner, embedded):
+        super().__init__(keyword, owner)
         self.embedded = embedded
 
     def matches(self, name):

{robotframework-6.1.1 → robotframework-7.0a1}/src/robot/running/userkeywordrunner.py

@@ -36,13 +36,9 @@ class UserKeywordRunner:
         self.pre_run_messages = ()
 
     @property
-    def longname(self):
-        libname = self._handler.libname
-        return f'{libname}.{self.name}' if libname else self.name
-
-    @property
-    def libname(self):
-        return self._handler.libname
+    def full_name(self):
+        owner = self._handler.owner
+        return f'{owner}.{self.name}' if owner else self.name
 
     @property
     def tags(self):
@@ -74,8 +70,8 @@ class UserKeywordRunner:
         doc = variables.replace_string(handler.doc, ignore_errors=True)
         doc, tags = split_tags_from_doc(doc)
         tags = variables.replace_list(handler.tags, ignore_errors=True) + tags
-        return KeywordResult(kwname=self.name,
-                             libname=handler.libname,
+        return KeywordResult(name=self.name,
+                             owner=handler.owner,
                              doc=getshortdoc(doc),
                              args=kw.args,
                              assign=tuple(assignment),
@@ -148,7 +144,8 @@ class UserKeywordRunner:
 
     def _trace_log_args_message(self, variables):
         return self._format_trace_log_args_message(
-            self._format_args_for_trace_logging(), variables)
+            self._format_args_for_trace_logging(), variables
+        )
 
     def _format_args_for_trace_logging(self):
         args = [f'${{{arg}}}' for arg in self.arguments.positional]
@@ -167,8 +164,10 @@ class UserKeywordRunner:
         if context.dry_run and handler.tags.robot('no-dry-run'):
             return None, None
         error = return_ = pass_ = None
+        if handler.setup:
+            error = self._run_setup_or_teardown(handler.setup, context)
         try:
-            BodyRunner(context).run(handler.body)
+            BodyRunner(context, run=not error).run(handler.body)
         except ReturnFromKeyword as exception:
             return_ = exception
             error = exception.earlier_failures
@@ -183,7 +182,7 @@ class UserKeywordRunner:
             error = exception
         if handler.teardown:
             with context.keyword_teardown(error):
-                td_error = self._run_teardown(handler.teardown, context)
+                td_error = self._run_setup_or_teardown(handler.teardown, context)
         else:
             td_error = None
         if error or td_error:
@@ -204,9 +203,9 @@ class UserKeywordRunner:
             return ret
         return ret[0]
 
-    def _run_teardown(self, teardown, context):
+    def _run_setup_or_teardown(self, item, context):
         try:
-            name = context.variables.replace_string(teardown.name)
+            name = context.variables.replace_string(item.name)
         except DataError as err:
             if context.dry_run:
                 return None
@@ -214,7 +213,7 @@ class UserKeywordRunner:
         if name.upper() in ('', 'NONE'):
             return None
         try:
-            KeywordRunner(context).run(teardown, name)
+            KeywordRunner(context).run(item, name)
         except PassExecution:
             return None
         except ExecutionStatus as err:
@@ -249,19 +248,17 @@ class EmbeddedArgumentsRunner(UserKeywordRunner):
         self.embedded_args = handler.embedded.match(name).groups()
 
     def _resolve_arguments(self, args, variables=None):
-        self.arguments.resolve(args, variables)
+        result = super()._resolve_arguments(args, variables)
         if variables:
             embedded = [variables.replace_scalar(e) for e in self.embedded_args]
             self.embedded_args = self._handler.embedded.map(embedded)
-        return super()._resolve_arguments(args, variables)
+        return result
 
     def _set_arguments(self, args, context):
         variables = context.variables
         for name, value in self.embedded_args:
             variables[f'${{{name}}}'] = value
         super()._set_arguments(args, context)
-        context.output.trace(lambda: self._trace_log_args_message(variables),
-                             write_if_flat=False)
 
     def _trace_log_args_message(self, variables):
         args = [f'${{{arg}}}' for arg in self._handler.embedded.args]
@@ -269,6 +266,6 @@ class EmbeddedArgumentsRunner(UserKeywordRunner):
         return self._format_trace_log_args_message(args, variables)
 
     def _get_result(self, kw, assignment, variables):
-        result = UserKeywordRunner._get_result(self, kw, assignment, variables)
-        result.sourcename = self._handler.name
+        result = super()._get_result(kw, assignment, variables)
+        result.source_name = self._handler.name
         return result