Addressing all feedback.

Author: fuzyll

binaryninjaapi.h

@@ -18905,9 +18905,9 @@ namespace BinaryNinja {
 		static void SetCurrentAddressCallback(void* ctxt, uint64_t addr);
 		static void SetCurrentSelectionCallback(void* ctxt, uint64_t begin, uint64_t end);
 		static char* CompleteInputCallback(void* ctxt, const char* text, uint64_t state);
+		static void StopCallback(void* ctxt);
 		static bool CanCompleteArgumentsCallback(void* ctxt, const char* text);
 		static char* CompleteArgumentsCallback(void* ctx, const char* text, uint64_t* argumentStart);
-		static void StopCallback(void* ctxt);
 
 		virtual void DestroyInstance();
 
@@ -18922,9 +18922,9 @@ namespace BinaryNinja {
 		virtual void SetCurrentAddress(uint64_t addr);
 		virtual void SetCurrentSelection(uint64_t begin, uint64_t end);
 		virtual std::string CompleteInput(const std::string& text, uint64_t state);
+		virtual void Stop();
 		virtual bool CanCompleteArguments(const std::string& text);
 		virtual std::string CompleteArguments(const std::string& text, uint64_t* argumentStart);
-		virtual void Stop();
 
 		void Output(const std::string& text);
 		void Warning(const std::string& text);
@@ -18958,9 +18958,9 @@ namespace BinaryNinja {
 		virtual void SetCurrentAddress(uint64_t addr) override;
 		virtual void SetCurrentSelection(uint64_t begin, uint64_t end) override;
 		virtual std::string CompleteInput(const std::string& text, uint64_t state) override;
+		virtual void Stop() override;
 		virtual bool CanCompleteArguments(const std::string& text) override;
 		virtual std::string CompleteArguments(const std::string& text, uint64_t* argumentStart) override;
-		virtual void Stop() override;
 	};
 
 	/*!

binaryninjacore.h

@@ -3121,9 +3121,9 @@ extern "C"
 		void (*setCurrentAddress)(void* ctxt, uint64_t addr);
 		void (*setCurrentSelection)(void* ctxt, uint64_t begin, uint64_t end);
 		char* (*completeInput)(void* ctxt, const char* text, uint64_t state);
+		void (*stop)(void* ctxt);
 		bool (*canCompleteArguments)(void* ctx, const char* text);
 		char* (*completeArguments)(void* ctxt, const char* text, uint64_t* argumentStart);
-		void (*stop)(void* ctxt);
 	} BNScriptingInstanceCallbacks;
 
 	typedef struct BNScriptingProviderCallbacks

python/bncompleter.py

@@ -72,6 +72,17 @@ def fnsignature(obj):
 	return sig
 
 
+def _format_annotation(annotation):
+	if isinstance(annotation, str):
+		return annotation
+	if isinstance(annotation, typing.ForwardRef):
+		return annotation.__forward_arg__
+	try:
+		return inspect.formatannotation(annotation)
+	except Exception:
+		return repr(annotation)
+
+
 class Completer:
 	def __init__(self, namespace=None):
 		"""Create a new completer for the command line.
@@ -101,9 +112,9 @@ def __init__(self, namespace=None):
 			self.namespace = namespace
 
 	def _resolve_callable(self, callable_path: str):
-		namespace = self.namespace
 		if self.use_main_ns:
 			self.namespace = __main__.__dict__
+		namespace = self.namespace
 		parts = callable_path.split(".")
 
 		if not parts:
@@ -184,6 +195,41 @@ def _is_keyword_unpack_argument(
 			and argument_tokens[0].string == "**"
 		)
 
+	@staticmethod
+	def _is_iterable_unpack_argument(
+		argument_tokens: typing.List[tokenize.TokenInfo]
+	) -> bool:
+		return (
+			len(argument_tokens) > 0
+			and argument_tokens[0].type == tokenize.OP
+			and argument_tokens[0].string == "*"
+		)
+
+	@staticmethod
+	def _var_positional_parameter_index(
+		parameters: typing.List[inspect.Parameter]
+	) -> Optional[int]:
+		return next(
+			(
+				index for index, parameter in enumerate(parameters)
+				if parameter.kind == inspect.Parameter.VAR_POSITIONAL
+			),
+			None,
+		)
+
+	@staticmethod
+	def _keyword_only_parameter_index(
+		parameters: typing.List[inspect.Parameter], used_keyword_parameters: typing.Set[str]
+	) -> Optional[int]:
+		return next(
+			(
+				index for index, parameter in enumerate(parameters)
+				if parameter.kind == inspect.Parameter.KEYWORD_ONLY
+				and parameter.name not in used_keyword_parameters
+			),
+			None,
+		)
+
 	@staticmethod
 	def _keyword_parameter_index(
 		parameters: typing.List[inspect.Parameter], keyword_name: str
@@ -241,13 +287,26 @@ def _current_argument_index(
 	) -> Optional[int]:
 		positional_argument_count = 0
 		used_keyword_parameters = set()
+		var_keyword_index = next(
+			(
+				index for index, parameter in enumerate(parameters)
+				if parameter.kind == inspect.Parameter.VAR_KEYWORD
+			),
+			None,
+		)
+		seen_var_keyword_argument = False
+		seen_iterable_unpack_argument = False
 
 		for argument_tokens in arguments[:-1]:
 			keyword_name = cls._keyword_argument_name(argument_tokens)
 			if keyword_name is not None:
 				parameter_index = cls._keyword_parameter_index(parameters, keyword_name)
 				if parameter_index is not None:
 					used_keyword_parameters.add(parameters[parameter_index].name)
+					if parameter_index == var_keyword_index:
+						seen_var_keyword_argument = True
+			elif cls._is_iterable_unpack_argument(argument_tokens):
+				seen_iterable_unpack_argument = True
 			elif not cls._is_keyword_unpack_argument(argument_tokens):
 				positional_argument_count += 1
 
@@ -257,14 +316,22 @@ def _current_argument_index(
 			return cls._keyword_parameter_index(parameters, keyword_name)
 
 		if cls._is_keyword_unpack_argument(current_argument):
-			for index, parameter in enumerate(parameters):
-				if parameter.kind == inspect.Parameter.VAR_KEYWORD:
-					return index
-			return None
+			return var_keyword_index
+		if cls._is_iterable_unpack_argument(current_argument):
+			return cls._var_positional_parameter_index(parameters)
+
+		if seen_var_keyword_argument:
+			return var_keyword_index
+		if seen_iterable_unpack_argument:
+			return cls._var_positional_parameter_index(parameters)
 
-		return cls._positional_parameter_index(
+		parameter_index = cls._positional_parameter_index(
 			parameters, positional_argument_count, used_keyword_parameters
 		)
+		if parameter_index is not None:
+			return parameter_index
+
+		return cls._keyword_only_parameter_index(parameters, used_keyword_parameters)
 
 	def _get_argument_completion_context(
 		self, text: str
@@ -276,9 +343,9 @@ def _get_argument_completion_context(
 		for line in text.splitlines(keepends=True):
 			line_offsets.append(line_offsets[-1] + len(line))
 
-		def absolute_index(position: typing.Tuple[int, int]) -> int:
+		def absolute_byte_index(position: typing.Tuple[int, int]) -> int:
 			line, column = position
-			return line_offsets[line - 1] + column
+			return len(text[:line_offsets[line - 1] + column].encode("utf-8"))
 
 		reader = io.StringIO(text).readline
 		stream = tokenize.generate_tokens(reader)
@@ -360,16 +427,14 @@ def absolute_index(position: typing.Tuple[int, int]) -> int:
 			return None
 
 		parameters = list(signature.parameters.values())
-		if not parameters:
-			return None
 
 		arguments = self._split_call_arguments(tokens, call_context["token_index"])
 
 		return {
 			"signature": signature,
 			"parameters": parameters,
 			"current_argument_index": self._current_argument_index(parameters, arguments),
-			"start_index": absolute_index(tokens[call_context["token_index"]].end),
+			"start_index": absolute_byte_index(tokens[call_context["token_index"]].end),
 		}
 
 	def can_complete_arguments(self, text: str) -> bool:
@@ -395,23 +460,19 @@ def complete_arguments(self, text: str) -> typing.Tuple[Optional[str], int]:
 		parameters = context["parameters"]
 		current_argument_index = context["current_argument_index"]
 
-
 		return_args = []
 		positional_only_count = sum(
 			1 for p in parameters if p.kind == inspect.Parameter.POSITIONAL_ONLY
 		)
 
 		for i, parameter in enumerate(parameters):
-			if positional_only_count > 0 and i == positional_only_count:
-				return_args.append("/")
-
 			if (
-					parameter.kind == inspect.Parameter.KEYWORD_ONLY
-					and "*" not in return_args
-					and not any(
-				p.kind == inspect.Parameter.VAR_POSITIONAL
-				for p in parameters[:i]
-			)
+				parameter.kind == inspect.Parameter.KEYWORD_ONLY
+				and "*" not in return_args
+				and not any(
+					p.kind == inspect.Parameter.VAR_POSITIONAL
+					for p in parameters[:i]
+				)
 			):
 				return_args.append("*")
 
@@ -425,10 +486,7 @@ def complete_arguments(self, text: str) -> typing.Tuple[Optional[str], int]:
 			if i == current_argument_index:
 				arg_postfix = ''
 				if parameter.annotation is not inspect.Signature.empty:
-					try:
-						annotation = inspect.formatannotation(parameter.annotation)
-					except Exception:
-						annotation = repr(parameter.annotation)
+					annotation = _format_annotation(parameter.annotation)
 					arg_postfix += f": {annotation}"
 
 				if parameter.default is not inspect.Signature.empty:
@@ -441,13 +499,13 @@ def complete_arguments(self, text: str) -> typing.Tuple[Optional[str], int]:
 
 			return_args.append(arg)
 
+			if positional_only_count > 0 and i + 1 == positional_only_count:
+				return_args.append("/")
+
 		result = ", ".join(return_args)
 
 		if signature.return_annotation is not inspect.Signature.empty:
-			try:
-				return_annotation = inspect.formatannotation(signature.return_annotation)
-			except Exception:
-				return_annotation = repr(signature.return_annotation)
+			return_annotation = _format_annotation(signature.return_annotation)
 			result += f'<span class="returnType"> -&gt; {html.escape(return_annotation)}</span>'
 
 		return result, context["start_index"]

python/scriptingprovider.py

@@ -271,7 +271,7 @@ def _can_complete_arguments(self, ctx, text):
 			if not isinstance(text, str):
 				text = text.decode("utf-8")
 			return self.perform_can_complete_arguments(text)
-		except:
+		except Exception:
 			logger.log_error_for_exception("Unhandled Python exception in ScriptingInstance._can_complete_arguments")
 			return False
 
@@ -284,10 +284,11 @@ def _complete_arguments(self, ctx, text, argument_start):
 			if result is None:
 				return None
 			return core.BNAllocString(result)
-		except:
+		except Exception:
 			logger.log_error_for_exception("Unhandled Python exception in ScriptingInstance._complete_arguments")
 			argument_start[0] = 0
 			return None
+
 	def _stop(self, ctxt):
 		try:
 			self.perform_stop()
@@ -1083,15 +1084,15 @@ def perform_complete_input(self, text, state):
 	def perform_can_complete_arguments(self, text: str) -> bool:
 		try:
 			self.interpreter.update_locals()
-		except:
+		except Exception:
 			traceback.print_exc()
 		return self.interpreter.completer.can_complete_arguments(text)
 
 	@abc.abstractmethod
 	def perform_complete_arguments(self, text: str) -> Tuple[Optional[str], int]:
 		try:
 			self.interpreter.update_locals()
-		except:
+		except Exception:
 			traceback.print_exc()
 		result = self.interpreter.completer.complete_arguments(text)
 		if result[0] is None:

scriptingprovider.cpp

@@ -56,12 +56,13 @@ void ScriptingOutputListener::NotifyInputReadyStateChanged(BNScriptingProviderIn
 
 ScriptingInstance::ScriptingInstance(ScriptingProvider* provider)
 {
-	BNScriptingInstanceCallbacks cb;
+	BNScriptingInstanceCallbacks cb = {};
 	cb.context = this;
 	cb.destroyInstance = DestroyInstanceCallback;
 	cb.externalRefTaken = nullptr;
 	cb.externalRefReleased = nullptr;
 	cb.executeScriptInput = ExecuteScriptInputCallback;
+	cb.executeScriptInputFromFilename = ExecuteScriptFromFilenameCallback;
 	cb.cancelScriptInput = CancelScriptInputCallback;
 	cb.releaseBinaryView = ReleaseBinaryViewCallback;
 	cb.setCurrentBinaryView = SetCurrentBinaryViewCallback;
@@ -70,9 +71,9 @@ ScriptingInstance::ScriptingInstance(ScriptingProvider* provider)
 	cb.setCurrentAddress = SetCurrentAddressCallback;
 	cb.setCurrentSelection = SetCurrentSelectionCallback;
 	cb.completeInput = CompleteInputCallback;
+	cb.stop = StopCallback;
 	cb.canCompleteArguments = CanCompleteArgumentsCallback;
 	cb.completeArguments = CompleteArgumentsCallback;
-	cb.stop = StopCallback;
 	AddRefForRegistration();
 	m_object = BNInitScriptingInstance(provider->GetObject(), &cb);
 }
@@ -98,6 +99,13 @@ BNScriptingProviderExecuteResult ScriptingInstance::ExecuteScriptInputCallback(v
 }
 
 
+BNScriptingProviderExecuteResult ScriptingInstance::ExecuteScriptFromFilenameCallback(void* ctxt, const char* filename)
+{
+	CallbackRef<ScriptingInstance> instance(ctxt);
+	return instance->ExecuteScriptInputFromFilename(filename);
+}
+
+
 void ScriptingInstance::CancelScriptInputCallback(void* ctxt)
 {
 	CallbackRef<ScriptingInstance> instance(ctxt);

ui/scriptingconsole.h

@@ -126,6 +126,7 @@ class BINARYNINJAUIAPI ScriptingConsoleEdit : public QTextEdit
 		std::atomic<uint64_t> latestRequest {0};
 		std::mutex callbackMutex;
 	};
+	static constexpr int ArgumentAssistDebounceInterval = 100;
 
 	ScriptingConsole* m_console;
 	int m_charHeight;
@@ -139,7 +140,10 @@ class BINARYNINJAUIAPI ScriptingConsoleEdit : public QTextEdit
 	CompleteArgumentsCallback m_completeArgumentsCallback;
 
 	ScriptingArgumentAssistPopup* m_argumentAssistPopup;
+	QTimer* m_argumentAssistUpdateTimer;
 	std::shared_ptr<ArgumentAssistRequestState> m_argumentAssistState;
+	bool m_argumentAssistRequestRunning;
+	bool m_argumentAssistRequestPending;
 	uint64_t m_argumentAssistPopupPosition;
 
 	uint64_t m_completionRegionStart;
@@ -148,6 +152,7 @@ class BINARYNINJAUIAPI ScriptingConsoleEdit : public QTextEdit
 
 	bool canShowArgumentAssistPopup() const;
 	void hideArgumentAssistPopup();
+	void scheduleArgumentAssistPopupUpdate();
 	void updateArgumentAssistPopup();
 	void applyArgumentAssistPopup(const QString& text, uint64_t popupPosition);