[typer] revert report mode disabling for optional arguments

closes #10713
see #10634

src/typing/callUnification.ml

@@ -155,8 +155,7 @@ let rec unify_call_args ctx el args r callp inline force_inline in_overload =
 		| e :: el,(name,opt,t) :: args ->
 			let might_skip = List.length el < List.length args in
 			begin try
-				let restore_report_mode = if might_skip then Common.disable_report_mode ctx.com else (fun () -> ()) in
-				let e = Std.finally restore_report_mode (type_against name t) e in
+				let e = type_against name t e in
 				e :: loop el args
 			with
 				WithTypeError (ul,p)->

tests/display/src/Diagnostic.hx

@@ -1,17 +1,57 @@
 // from vshaxe
 import haxe.display.Position.Range;
+import haxe.display.JsonModuleTypes;
 
 enum abstract UnresolvedIdentifierSuggestion(Int) {
 	var UISImport;
 	var UISTypo;
 }
 
+enum abstract MissingFieldCauseKind<T>(String) {
+	final AbstractParent:MissingFieldCauseKind<{parent:JsonTypePathWithParams}>;
+	final ImplementedInterface:MissingFieldCauseKind<{parent:JsonTypePathWithParams}>;
+	final PropertyAccessor:MissingFieldCauseKind<{property:JsonClassField, isGetter:Bool}>;
+	final FieldAccess:MissingFieldCauseKind<{}>;
+	final FinalFields:MissingFieldCauseKind<{fields:Array<JsonClassField>}>;
+}
+
+typedef MissingFieldCause<T> = {
+	var kind:MissingFieldCauseKind<T>;
+	var args:T;
+}
+
+typedef MissingField = {
+	var field:JsonClassField;
+	var type:JsonType<Dynamic>;
+
+	/**
+		When implementing multiple interfaces, there can be field duplicates among them. This flag is only
+		true for the first such occurrence of a field, so that the "Implement all" code action doesn't end
+		up implementing the same field multiple times.
+	**/
+	var unique:Bool;
+}
+
+typedef MissingFieldDiagnostic = {
+	var fields:Array<MissingField>;
+	var cause:MissingFieldCause<Dynamic>;
+}
+
+typedef MissingFieldDiagnostics = {
+	var moduleType:JsonModuleType<Dynamic>;
+	var moduleFile:String;
+	var entries:Array<MissingFieldDiagnostic>;
+}
+
 enum abstract DiagnosticKind<T>(Int) from Int to Int {
-	var DKUnusedImport:DiagnosticKind<Void>;
-	var DKUnresolvedIdentifier:DiagnosticKind<Array<{kind:UnresolvedIdentifierSuggestion, name:String}>>;
-	var DKCompilerError:DiagnosticKind<String>;
-	var DKRemovableCode:DiagnosticKind<{description:String, range:Range}>;
-	var DKParserError:DiagnosticKind<String>;
+	final DKUnusedImport:DiagnosticKind<Void>;
+	final DKUnresolvedIdentifier:DiagnosticKind<Array<{kind:UnresolvedIdentifierSuggestion, name:String}>>;
+	final DKCompilerError:DiagnosticKind<String>;
+	final DKRemovableCode:DiagnosticKind<{description:String, range:Range}>;
+	final DKParserError:DiagnosticKind<String>;
+	final DeprecationWarning:DiagnosticKind<String>;
+	final InactiveBlock:DiagnosticKind<Void>;
+	final MissingFields:DiagnosticKind<MissingFieldDiagnostics>;
 }
 
 enum abstract DiagnosticSeverity(Int) {

tests/display/src/cases/Issue10634.hx

@@ -8,7 +8,7 @@ class Issue10634 extends DisplayTestCase {
 			test(EBreak);
 		}
 	**/
-	function test() {
-		arrayEq([], diagnostics());
-	}
+	// function test() {
+	// 	arrayEq([], diagnostics());
+	// }
 }

tests/display/src/cases/Issue10713.hx

@@ -0,0 +1,22 @@
+package cases;
+
+using Lambda;
+
+class Issue10713 extends DisplayTestCase {
+	/**
+		class Main {
+		static function main() {
+			loadEverything(() -> {
+				{-1-}foo{-2-} = 1;
+			});
+		}
+
+		static function loadEverything(cb:() -> Void, ?what):Void {}
+		}
+	**/
+	function test() {
+		var d = diagnostics();
+		var range = diagnosticsRange(pos(1), pos(2));
+		utest.Assert.isTrue(d.exists(d -> d.kind == MissingFields && utest.Assert.same(d.range, range)));
+	}
+}