fix: Intellisense doesn't work when importing yml file with variables #143

Author: d-biehl

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -585,11 +585,22 @@ async def get_command_line_variables(self) -> List[VariableDefinition]:
                     name, args = split_args_from_name_or_path(str(variable_file))
                     try:
                         lib_doc = await self.get_libdoc_for_variables_import(
-                            name, tuple(args), str(self.folder.to_path()), self, resolve_command_line_vars=False
+                            name,
+                            tuple(args),
+                            str(self.folder.to_path()),
+                            self,
+                            resolve_variables=False,
+                            resolve_command_line_vars=False,
                         )
                         if lib_doc is not None:
                             command_line_vars += lib_doc.variables
 
+                            if lib_doc.errors:
+                                # TODO add diagnostics
+                                for error in lib_doc.errors:
+                                    self._logger.error(
+                                        lambda: f"{error.type_name}: {error.message} in {error.source}:{error.line_no}"
+                                    )
                     except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
                         raise
                     except BaseException as e:
@@ -604,11 +615,23 @@ async def get_command_line_variables(self) -> List[VariableDefinition]:
                     name, args = split_args_from_name_or_path(variable_file)
                     try:
                         lib_doc = await self.get_libdoc_for_variables_import(
-                            name, tuple(args), str(self.folder.to_path()), self, resolve_command_line_vars=False
+                            name,
+                            tuple(args),
+                            str(self.folder.to_path()),
+                            self,
+                            resolve_variables=False,
+                            resolve_command_line_vars=False,
                         )
                         if lib_doc is not None:
                             command_line_vars += lib_doc.variables
 
+                            if lib_doc.errors:
+                                # TODO add diagnostics
+                                for error in lib_doc.errors:
+                                    self._logger.error(
+                                        lambda: f"{error.type_name}: {error.message} in {error.source}:{error.line_no}"
+                                    )
+
                     except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
                         raise
                     except BaseException as e:
@@ -878,12 +901,16 @@ async def get_variables_meta(
         name: str,
         base_dir: str = ".",
         variables: Optional[Dict[str, Optional[Any]]] = None,
+        resolve_variables: bool = True,
+        resolve_command_line_vars: bool = True,
     ) -> Tuple[Optional[LibraryMetaData], str]:
         try:
             import_name = await self.find_variables(
                 name,
                 base_dir=base_dir,
                 variables=variables,
+                resolve_variables=resolve_variables,
+                resolve_command_line_vars=resolve_command_line_vars,
             )
 
             result: Optional[LibraryMetaData] = None
@@ -935,7 +962,7 @@ async def get_variables_meta(
         except BaseException:
             pass
 
-        return None, import_name
+        return None, name
 
     async def find_library(self, name: str, base_dir: str, variables: Optional[Dict[str, Any]] = None) -> str:
         return await self._library_files_cache.get(self._find_library, name, base_dir, variables)
@@ -986,19 +1013,35 @@ async def __find_resource(
 
         return str(find_file_ex(name, base_dir, file_type))
 
-    async def find_variables(self, name: str, base_dir: str, variables: Optional[Dict[str, Any]] = None) -> str:
-        return await self._variables_files_cache.get(self.__find_variables, name, base_dir, variables)
+    async def find_variables(
+        self,
+        name: str,
+        base_dir: str,
+        variables: Optional[Dict[str, Any]] = None,
+        resolve_variables: bool = True,
+        resolve_command_line_vars: bool = True,
+    ) -> str:
+        return await self._variables_files_cache.get(
+            self.__find_variables, name, base_dir, variables, resolve_command_line_vars
+        )
 
     @_logger.call
-    async def __find_variables(self, name: str, base_dir: str, variables: Optional[Dict[str, Any]] = None) -> str:
+    async def __find_variables(
+        self,
+        name: str,
+        base_dir: str,
+        variables: Optional[Dict[str, Any]] = None,
+        resolve_variables: bool = True,
+        resolve_command_line_vars: bool = True,
+    ) -> str:
         from robot.variables.search import contains_variable
 
-        if contains_variable(name, "$@&%"):
+        if resolve_variables and contains_variable(name, "$@&%"):
             return find_variables(
                 name,
                 str(self.folder.to_path()),
                 base_dir,
-                await self.get_resolvable_command_line_variables(),
+                await self.get_resolvable_command_line_variables() if resolve_command_line_vars else None,
                 variables,
             )
 
@@ -1258,19 +1301,23 @@ async def get_libdoc_for_variables_import(
         base_dir: str,
         sentinel: Any = None,
         variables: Optional[Dict[str, Any]] = None,
+        resolve_variables: bool = True,
         resolve_command_line_vars: bool = True,
     ) -> VariablesDoc:
         source = await self.find_variables(
             name,
             base_dir,
             variables,
+            resolve_variables=resolve_variables,
+            resolve_command_line_vars=resolve_command_line_vars,
         )
 
         async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_dir: str) -> VariablesDoc:
             meta, source = await self.get_variables_meta(
                 name,
                 base_dir,
                 variables,
+                resolve_command_line_vars=resolve_command_line_vars,
             )
 
             self._logger.debug(lambda: f"Load variables {source}{args!r}")

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -1546,7 +1546,8 @@ def get_variables_doc(
             if import_name.lower().endswith((".yaml", ".yml")):
                 source = import_name
                 importer = YamlImporter()
-            if get_robot_version() >= (6, 1) and import_name.lower().endswith(".json"):
+            elif get_robot_version() >= (6, 1) and import_name.lower().endswith(".json"):
+                source = import_name
                 importer = JsonImporter()
             else:
                 if not is_variables_by_path(import_name):

tests/robotcode/language_server/robotframework/parts/data/.vscode/settings.json

@@ -46,4 +46,7 @@
     //     "TRACE",
     //     "--log-calls"
     // ],
+    "robotcode.robot.variableFiles": [
+        "${EXECDIR}/resources/testvars.yml"
+    ]
 }