Improve copy-down-method and io performance (#1752)

Fixes #1749
Fixes #1743
Fixes #1097

Author: housel

documentation/source/release-notes/2025.2.rst

@@ -32,11 +32,40 @@ Compiler
   encountering the situation outlined in `Issue 1377
   <https://github.com/dylan-lang/opendylan/issues/1377>`_.
 
+* Repeated optimization involving lifting closures to top level now
+  properly preserves types of local bindings.
+
+* Optimization of the type estimation of :drm:`if` expressions can now
+  be repeated multiple times as the function is iteratively improved.
+
+* The compiler now supports an extended version of
+  ``copy-down-method-definer`` allowing a ``specializing`` clause
+  selecting which of the more-general methods should be selected for
+  inlining in the case of dispatch ambiguity. Additionally, ambiguous
+  ``copy-down-method`` definitions are now signaled as serious
+  warnings rather than allowing a random applicable method to be
+  chosen for inlining.
+
 Tools
 =====
 
 Library Updates
 ===============
 
+Dylan
+-----
+
+* A number of ``copy-down-method`` definitions in the :lib:`dylan`
+  library that were previously marked as ambiguous have been
+  corrected.
+
+io
+---
+
+* Specific versions of the stream functions sealed on
+  ``<byte-char-file-stream>`` and ``<byte-file-stream>`` are provided,
+  significantly improving the performance of these stream operations.
+
+
 Contributors
 ============

sources/dfmc/conversion/define-function.dylan

@@ -59,18 +59,10 @@ end function;
 // to the dynamic case, in which case any problems are reported
 // as for references in code.
 
-/*
 define program-warning <dynamic-specializer-expressions>
-  slot condition-form,
-    init-keyword: form:;
-  slot condition-specializer-expressions,
-    init-keyword: specializer-expressions:;
   format-string
-    "The specializers %= of %= cannot be computed at compile-time -- optimizations may be missed.";
-  format-arguments
-    specializer-expressions, form;
+    "Specializers cannot be computed at compile-time -- optimizations may be missed.";
 end program-warning;
-*/
 
 define function compute-variable-specs-types
     (form, variable-specs :: <variable-specs>)

sources/dfmc/conversion/define-method.dylan

@@ -240,6 +240,23 @@ define compiler-sideways method compute-form-model-object
   end;
 end method;
 
+define compiler-sideways method compute-form-model-object
+    (form :: <copy-down-method-definition>, name :: <variable-name-fragment>)
+ => (model :: false-or(<&method>));
+  let method-object = next-method();
+  if (form.form-specializing-signature)
+    let (specializing-sig-object, static?)
+      = compute-signature(form, form.form-specializing-signature);
+    if (static?)
+      method-object.specializing-signature := specializing-sig-object;
+    else
+      note(<dynamic-specializer-expressions>,
+           source-location: form-source-location(form));
+    end if;
+  end if;
+  method-object
+end method;
+
 define compiler-sideways method form-top-level-methods
     (form :: <method-definition>) => (methods :: <sequence>)
   let inits = next-method();

sources/dfmc/debug-back-end/print-object.dylan

@@ -12,9 +12,9 @@ define compiler-sideways method print-object
     (o :: <named-object>, stream :: <stream>) => ()
   if (o.named?)
     if (*verbose-objects?*)
-      format(stream, "{%s %s}", o.object-class, o.name);
+      format(stream, "{%s %s/%=}", o.object-class, o.name, o.node-id);
     else
-      format(stream, "{%s}", o.name);
+      format(stream, "{%s/%=}", o.name, o.node-id);
     end if;
   else
     next-method();

sources/dfmc/definitions/define-copy-down.dylan

@@ -6,10 +6,18 @@ Copyright:    Original Code is Copyright (c) 1995-2004 Functional Objects, Inc.
 License:      See License.txt in this distribution for details.
 Warranty:     Distributed WITHOUT WARRANTY OF ANY KIND
 
+define dood-class <copy-down-method-definition> (<method-definition>)
+  lazy constant slot form-specializing-signature,
+    required-init-keyword: specializing-signature:;
+end;
 
 define &definition copy-down-method-definer
+  { define ?mods:* \copy-down-method ?:name ?signature:*
+      specializing ?specializing-signature:* }
+    => do-define-copy-down-method(form, mods, name, signature,
+                                  specializing-signature);
   { define ?mods:* \copy-down-method ?:name ?signature:* }
-    => do-define-copy-down-method (form, mods, name, signature) ;
+    => do-define-copy-down-method(form, mods, name, signature, #f);
   { define ?mods:* \copy-down-method ?other:* }
     => begin
          note(<malformed-define-method>,
@@ -18,53 +26,31 @@ define &definition copy-down-method-definer
        end;
 end;
 
-/*
-define function do-define-copy-down-method (fragment, mods, name, signature)
-format-out ("in do-define-copy-down-method\n");
-  // let (options, adjectives) = parse-method-adjectives (name, mods);
-format-out ("copy-down-method signature is %s\n", signature) ;
-  // maybe should check body is empty
-  // ensure-next-method-binding (signature);  // not sure this useful
-//  let  args-list = macro-case (signature) { (?args:*) ?other:* } => args end;
-  let  method-form
-    = #{ define ?mods \method ?name ?signature end };
-  let  new-fragment = method-form.as-body ;
-  let  expanded-forms = top-level-convert (fragment, new-fragment) ;
-format-out ("expanded forms for copy-down method %s\n", expanded-forms) ;
-  let  interesting-form = first (expanded-forms) ;
-  interesting-form.form-class := #"copy-down-method" ;
-  expanded-forms
-end;
-*/
-define function do-define-copy-down-method (fragment, mods, name, signature)
-// format-out ("in do-define-copy-down-method\n");
+define function do-define-copy-down-method
+    (fragment, mods, name, sig-fragment, specializing-sig-fragment)
   let (options, adjectives) = parse-method-adjectives (name, mods);
-//  let signature-and-body = make (<sequence-fragment>,
-//                                 record: signature.fragment-record,
-//                                 source-position: signature.fragment-source-position,
-//                                 fragments:
-//                                   concatenate (signature . fragment-fragments,
-//                                                #{ #f }.template-fragments)) ;
-  let signature-and-body = signature ;
-  let (signature, body) = parse-method-signature(name, signature-and-body);
-// format-out ("copy-down-method signature is %s\n", signature) ;
+  let (signature, body) = parse-method-signature(name, sig-fragment);
   ensure-next-method-binding (signature);
+  let specializing-signature
+    = specializing-sig-fragment
+    & parse-method-signature(name, specializing-sig-fragment);
   let method-definition
-    = apply(make, <method-definition>,
+    = apply(make, <copy-down-method-definition>,
             source-location: fragment-source-location(fragment),
             variable-name:   name,
             adjectives:      adjectives,
             signature:       signature,
+            specializing-signature: specializing-signature,
             body:            body,
-            signature-and-body-fragment: signature,
+            signature-and-body-fragment: sig-fragment,
             options);
-  method-definition.form-class  := #"copy-down-method" ;
+  method-definition.form-class := #"copy-down-method" ;
   if (form-sealed?(method-definition))
     let domain-fragment
       = generate-implicit-domain-definition-fragment(method-definition);
-    let expanded-forms = top-level-convert(method-definition, domain-fragment) ;
-    pair (method-definition, expanded-forms)
+    let expanded-forms = top-level-convert(method-definition, domain-fragment);
+    pair(method-definition, expanded-forms)
   else
-    list (method-definition)
+    list(method-definition)
   end
 end;

sources/dfmc/definitions/definitions-library.dylan

@@ -161,6 +161,9 @@ define module dfmc-definitions
     form-handled-by-make-when-dynamic?,
     ensure-next-method-binding;
 
+  export <copy-down-method-definition>,
+    form-specializing-signature;
+
   export <domain-definition>,
     domain-definition?,
     form-domain-type-expressions;

sources/dfmc/flow-graph/environment.dylan

@@ -517,6 +517,18 @@ define method extract-lambda (code :: <&code>) => ()
   extract-lambda(function(code))
 end;
 
+define function lambda-make-closure
+    (lambda :: <&lambda>) => (res :: false-or(<make-closure>))
+  block (return)
+    for (user in users(lambda))
+      if (instance?(user, <make-closure>))
+        return(user)
+      end if;
+    end for;
+    #f
+  end block;
+end function;
+
 // Walk the lexical variables of the environment in inside out order.
 
 // define generic do-lexical-variables-in-scope

sources/dfmc/flow-graph/flow-graph-library.dylan

@@ -33,13 +33,7 @@ define module dfmc-flow-graph
   use dfmc-reader;
 
   export
-    ensure-invariants,
-    <closure-entry-strength>,
-    $no-closure-entry,
-    $weak-closure-entry,
-    $strong-closure-entry,
-    do-over-lambda-users,
-    analyze-environments;
+    ensure-invariants;
 
   export
     <inlined-origin>,
@@ -289,6 +283,7 @@ define module dfmc-flow-graph
     inners, inners-setter,
     lambda, lambda-setter,
     closure, closure-setter,
+    lifture, lifture-setter,
     entries, entries-setter,
     loops, loops-setter,
     lambda-loop, lambda-loop-setter,

sources/dfmc/flow-graph/flow-graph.lid

@@ -8,7 +8,6 @@ Files:   flow-graph-library
          computation
          c-computation
          utilities
-         closure
          checker
          walker
          queue-ops

sources/dfmc/modeling/functions.dylan

@@ -679,6 +679,10 @@ end method;
 // markt, this represents a copy-down method skeleton.
 
 define &class <copy-down-method> (<method>)
+  // Compile-time slots.
+  slot specializing-signature :: false-or(<&signature>),
+    init-value: #f,
+    init-keyword: specializing-signature:;
 end &class;
 
 define &class <simple-copy-down-method> (<copy-down-method>, <simple-method>)