Support all option types in the project file

Source/DafnyCore.Test/DafnyProjectTest.cs

@@ -28,13 +28,13 @@ public void Equality() {
 
     Assert.Equal(first, second);
 
-    first.Options.Add("k", new[] { 1, 2, 3 });
-    second.Options.Add("k", new[] { 1, 2, 3 });
+    first.Options.Add("k", "1, 2, 3");
+    second.Options.Add("k", "1, 2, 3");
 
     Assert.Equal(first, second);
 
-    first.Options.Add("m", new[] { 1, 2, 3 });
-    second.Options.Add("m", new[] { 3, 2, 1 });
+    first.Options.Add("m", "1, 2, 3");
+    second.Options.Add("m", "3, 2, 1");
     Assert.NotEqual(first, second);
   }
 }

Source/DafnyCore/DooFile.cs

@@ -1,18 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
-using System.CommandLine.Binding;
-using System.Configuration;
 using System.IO;
 using System.IO.Compression;
 using System.Linq;
 using System.Text;
-using System.Threading;
+using DafnyCore.Generic;
 using Microsoft.Dafny;
-using Microsoft.Dafny.Auditor;
 using Tomlyn;
-using Tomlyn.Model;
-using Type = System.Type;
 
 namespace DafnyCore; 
 
@@ -137,7 +132,7 @@ public bool Validate(string filePath, DafnyOptions options, Command currentComma
 
       object libraryValue = null;
       if (Manifest.Options.TryGetValue(option.Name, out var manifestValue)) {
-        if (!DafnyProject.TryGetValueFromToml(Console.Out, null,
+        if (!TomlUtil.TryGetValueFromToml(Console.Out, null,
               option.Name, option.ValueType, manifestValue, out libraryValue)) {
           return false;
         }

Source/DafnyCore/Generic/TomlUtil.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Tomlyn.Model;
+
+namespace DafnyCore.Generic; 
+
+public static class TomlUtil {
+
+  public static bool TryGetValueFromToml(TextWriter errorWriter, string sourceDir, string tomlPath, Type type, object tomlValue, out object value) {
+    if (tomlValue == null) {
+      value = null;
+      return false;
+    }
+
+    if (type.IsAssignableFrom(typeof(List<string>))) {
+      return TryGetListValueFromToml<string>(errorWriter, sourceDir, tomlPath, (TomlArray)tomlValue, out value);
+    }
+    if (type.IsAssignableFrom(typeof(List<FileInfo>))) {
+      return TryGetListValueFromToml<FileInfo>(errorWriter, sourceDir, tomlPath, (TomlArray)tomlValue, out value);
+    }
+
+    if (tomlValue is string tomlString) {
+      if (type == typeof(FileInfo)) {
+        // Need to make sure relative paths are interpreted relative to the source of the value,
+        // not the current directory.
+        var fullPath = sourceDir != null ? Path.GetFullPath(tomlString, sourceDir) : tomlString;
+        value = new FileInfo(fullPath);
+        return true;
+      }
+
+      if (typeof(Enum).IsAssignableFrom(type)) {
+        try {
+          value = Enum.Parse(type, tomlString);
+          return true;
+        } catch (ArgumentException) {
+          value = null;
+          return false;
+        }
+      }
+    }
+
+    if (!type.IsInstanceOfType(tomlValue)) {
+      if (type == typeof(string)) {
+        value = tomlValue.ToString();
+        return true;
+      }
+      errorWriter.WriteLine(
+        $"Error: property '{tomlPath}' is of type '{tomlValue.GetType()}' but should be of type '{type}'");
+      value = null;
+      return false;
+    }
+
+    value = tomlValue;
+    return true;
+  }
+
+  private static bool TryGetListValueFromToml<T>(TextWriter errorWriter, string sourceDir, string tomlPath, TomlArray tomlValue, out object value) {
+    var success = true;
+    value = tomlValue.Select((e, i) => {
+      if (TryGetValueFromToml(errorWriter, sourceDir, $"{tomlPath}[{i}]", typeof(T), e, out var elementValue)) {
+        return (T)elementValue;
+      }
+      success = false;
+      return default(T);
+    }).ToList();
+    return success;
+  }
+}

Source/DafnyCore/Options/DafnyProject.cs

@@ -2,9 +2,12 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.CommandLine;
+using System.CommandLine.Parsing;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.Serialization;
+using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DafnyCore.Options;
@@ -140,55 +143,41 @@ public bool TryGetValue(Option option, TextWriter errorWriter, out object value)
       return false;
     }
 
-    return TryGetValueFromToml(errorWriter, Path.GetDirectoryName(Uri.LocalPath), option.Name, option.ValueType, tomlValue, out value);
-  }
-
-  public static bool TryGetValueFromToml(TextWriter errorWriter, string sourceDir, string tomlPath, System.Type type, object tomlValue, out object value) {
-    if (tomlValue == null) {
+    var printTomlValue = PrintTomlOptionToCliValue(tomlValue, option);
+    var parseResult = option.Parse(new[] { option.Aliases.First(), printTomlValue });
+    if (parseResult.Errors.Any()) {
+      errorWriter.WriteLine($"Error: Could not parse value '{tomlValue}' for option '{option.Name}' that has type '{option.ValueType.Name}'");
       value = null;
       return false;
     }
+    // By using the dynamic keyword, we can use the generic version of GetValueForOption which does type conversion,
+    // which is sadly not accessible without generics.
+    value = parseResult.GetValueForOption((dynamic)option);
+    return true;
+  }
 
-    if (type.IsAssignableFrom(typeof(List<string>))) {
-      return TryGetListValueFromToml<string>(errorWriter, sourceDir, tomlPath, (TomlArray)tomlValue, out value);
-    }
-    if (type.IsAssignableFrom(typeof(List<FileInfo>))) {
-      return TryGetListValueFromToml<FileInfo>(errorWriter, sourceDir, tomlPath, (TomlArray)tomlValue, out value);
-    }
+  string PrintTomlOptionToCliValue(object value, Option valueType) {
+    var projectDirectory = Path.GetDirectoryName(Uri.LocalPath);
 
-    if (type == typeof(FileInfo) && tomlValue is string tomlString) {
-      // Need to make sure relative paths are interpreted relative to the source of the value,
-      // not the current directory.
-      var fullPath = sourceDir != null ? Path.GetFullPath(tomlString, sourceDir) : tomlString;
-      value = new FileInfo(fullPath);
-      return true;
-    }
+    if (value is TomlArray array) {
+      if (valueType.ValueType.IsAssignableTo(typeof(IEnumerable<FileInfo>))) {
+        return string.Join(" ", array.Select(element => {
+          if (element is string elementString) {
+            return Path.GetFullPath(elementString, projectDirectory!);
+          }
 
-    if (!type.IsInstanceOfType(tomlValue)) {
-      if (type == typeof(string)) {
-        value = tomlValue.ToString();
-        return true;
+          return element.ToString();
+        }));
       }
-      errorWriter.WriteLine(
-        $"Error: property '{tomlPath}' is of type '{tomlValue.GetType()}' but should be of type '{type}'");
-      value = null;
-      return false;
+
+      return string.Join(" ", array);
     }
 
-    value = tomlValue;
-    return true;
-  }
+    if (value is string stringValue && valueType.ValueType == typeof(FileInfo)) {
+      value = Path.GetFullPath(stringValue, projectDirectory);
+    }
 
-  private static bool TryGetListValueFromToml<T>(TextWriter errorWriter, string sourceDir, string tomlPath, TomlArray tomlValue, out object value) {
-    var success = true;
-    value = tomlValue.Select((e, i) => {
-      if (TryGetValueFromToml(errorWriter, sourceDir, $"{tomlPath}[{i}]", typeof(T), e, out var elementValue)) {
-        return (T)elementValue;
-      }
-      success = false;
-      return default(T);
-    }).ToList();
-    return success;
+    return value.ToString();
   }
 
   public bool Equals(DafnyProject other) {

Source/DafnyLanguageServer.Test/DafnyLanguageServerTestBase.cs

@@ -41,6 +41,8 @@ requires p > 0 && q > 0
   }
 }".TrimStart();
 
+    protected string SlowToVerifyNoLimit => SlowToVerify.Replace(" {:rlimit 100}", "");
+
     protected readonly string NeverVerifies = @"
 lemma {:neverVerify} HasNeverVerifyAttribute(p: nat, q: nat)
   ensures true

Source/DafnyLanguageServer.Test/ProjectFiles/ProjectFilesTest.cs

@@ -100,6 +100,7 @@ public async Task ClosestProjectFileIsFound() {
   public async Task ProjectFileOverridesOptions() {
     await SetUp(options => {
       options.Set(Function.FunctionSyntaxOption, "3");
+      options.Set(CommonOptionBag.QuantifierSyntax, QuantifierSyntaxOptions.Version3);
       options.Set(CommonOptionBag.WarnShadowing, true);
     });
     var source = @"
@@ -110,13 +111,18 @@ method Foo() {
   }
 }
 
+function Zoo(): set<(int,int)> {
+  set x: int | 0 <= x < 5, y | 0 <= y < 6 :: (x,y)
+}
+
 ghost function Bar(): int { 3 }".TrimStart();
 
     var projectFileSource = @"
 includes = [""**/*.dfy""]
 
 [options]
 warn-shadowing = false
+quantifier-syntax = 4
 function-syntax = 4";
 
     var directory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
@@ -127,7 +133,9 @@ method Foo() {
     Assert.Single(diagnostics1); // Stops after parsing
 
     await File.WriteAllTextAsync(Path.Combine(directory, DafnyProject.FileName), projectFileSource);
-    await CreateAndOpenTestDocument(source, Path.Combine(directory, "source.dfy"));
+    var sourceFile = await CreateAndOpenTestDocument(source, Path.Combine(directory, "source.dfy"));
+    var diagnostics2 = await GetLastDiagnostics(sourceFile, CancellationToken);
+    Assert.Empty(diagnostics2.Where(d => d.Severity == DiagnosticSeverity.Error));
     await AssertNoDiagnosticsAreComing(CancellationToken);
   }
 

Source/DafnyLanguageServer.Test/Synchronization/DiagnosticsTest.cs

@@ -1082,7 +1082,7 @@ public async Task ApplyChangeBeforeVerificationFinishes() {
 method test() {
   assert false;
 }
-".TrimStart() + SlowToVerify;
+".TrimStart() + SlowToVerifyNoLimit;
       await SetUp(options => options.Set(BoogieOptionBag.Cores, 1U));
       var documentItem = CreateTestDocument(source, "ApplyChangeBeforeVerificationFinishes.dfy");
       client.OpenDocument(documentItem);

Test/cli/projectFile/projectFile.dfy.expect

@@ -9,7 +9,7 @@ Warning: only Dafny project files named dfyconfig.toml are recognised by the Daf
 Warning: option 'does-not-exist' that was specified in the project file, is not a valid Dafny option.
 
 Dafny program verifier did not attempt verification
-Error: property 'warn-shadowing' is of type 'System.Int64' but should be of type 'System.Boolean'
+Error: Could not parse value '3' for option 'warn-shadowing' that has type 'Boolean'
 input.dfy(6,8): Warning: Shadowed local-variable name: x
 moreInput.dfy(6,8): Warning: Shadowed local-variable name: x
 

docs/dev/news/4435.feat

@@ -1,10 +1,10 @@
 The Dafny IDE now has improved behavior when working with a Dafny file that's part of a Dafny project. A Dafny file is part of a project if a `dfyconfig.toml` can be found somewhere in the file's path hierarchy, such as in the same folder or in the parent folder. A `dfyconfig.toml` can specify which Dafny options to use for that project, and can specify which Dafny files are part of the project. By default, the project will include all .dfy files reachable from the folder in which the `dfyconfig.toml` resides. Project related features of the IDE are:
 - Whenever one file in the project is opened, diagnostics for all files in the Dafny project are shown. When including a file with errors that's part of the same project, the message "the included file contains errors" is no longer shown. Instead, the included file's errors are shown directly.
-- If any file in the project in changed, diagnostics for all files in the project are updated. Without a project, changing an included file will not update diagnostics for the including file until the including file is also changed.
-- If any file in the project is resolved, all files in the project are resolved. Opening a file in a project that's already resolved means the opened file is resolved instantly.
-- The IDE's memory consumption stays the same regardless of how many files in a project are opened. Without a project, the IDE increases it's memory usage for each open file.
+- If any file in the project is changed, diagnostics for all files in the project are updated. Without a project, changing an included file will not update diagnostics for the including file until the including file is also changed.
 - The find references feature (also added in this release), works better in files that are part of a project, since only then can it find references that are inside files that include the current file.
 - The assisted rename feature (also added in this release), only works for files that are part of a project.
-- For files that are part of a project, the Dafny IDE does not require the use of include directives to work, and neither does the CLI if you run it using the project file. This means that Dafny projects can be used without use include directives for files inside the project. When using library files that are outside the project, it's still necessary to use includes.
+- When using a project file, it is no longer necessary to use include directives. In the previous version of Dafny, it was already the case that the Dafny CLI, when passed a Dafny project file, does not require include directives to process the Dafny program. The same now holds for the Dafny IDE when working with Dafny files for which a project file can be found.
+- If any file in the project is resolved, all files in the project are resolved. Opening a file in a project that's already resolved means the opened file is resolved instantly.
+- The IDE's memory consumption stays the same regardless of how many files in a project are opened. Without a project, the IDE increases it's memory usage for each open file.
 
 Try out the IDE's project support now by creating an empty `dfyconfig.toml` file in the root of your project repository.

docs/dev/news/4506.fix

@@ -0,0 +1 @@
+Support all types of options in the Dafny project file (dfyconfig.toml)