Merge remote-tracking branch 'origin/topic/robin/gh-1123-ctor-express…

…ions'

* origin/topic/robin/gh-1123-ctor-expressions: (23 commits)
  Change SafeInt repository over to a fork including a fix.
  Fix issue in Bison grammar.
  Suppress GCC warnings.
  Fix a couple of unit tests for Alpine.
  Fix clang-tidy warnings.
  Fix printing of ID scopes.
  Fix printing of enum constants.
  Add boolean folding.
  Outsource an integer range check to SafeInt.
  Suppress clang-tidy warnings.
  Remove debugging output from integer range checks.
  Add test to check substitution of ctor nodes.
  Update printer to output type constructors.
  Move ctor replacement from normalizer into constant folder.
  Add test exercising various integer out-of-range situations.
  Add general constant folding.
  Rework integer out-of-range checking.
  Move negation out of parser.
  Address review feedback.
  Port `port` ctor expression to new model.
  ...

.clang-tidy

@@ -31,6 +31,7 @@ Checks: '
   -misc-unused-parameters,
   -misc-const-correctness,
   -misc-confusable-identifiers,
+  -misc-const-correctness,
 
   modernize-*,
   -modernize-avoid-c-arrays,

.gitmodules

@@ -3,7 +3,7 @@
 	url = https://github.com/onqtam/doctest.git
 [submodule "3rdparty/SafeInt"]
 	path = 3rdparty/SafeInt
-	url = https://github.com/dcleblanc/SafeInt
+	url = https://github.com/rsmmr/SafeInt.git
 [submodule "3rdparty/ArticleEnumClass-v2"]
 	path = 3rdparty/ArticleEnumClass-v2
 	url = https://github.com/Dalzhim/ArticleEnumClass-v2

CHANGES

@@ -1,3 +1,31 @@
+1.7.0-dev.78 | 2023-01-27 11:16:01 +0100
+
+  * GH-1123: Support arbitrary expression as argument to type
+    constructors, such as `interval(...)`. (Robin Sommer, Corelight)
+
+    So far we used constructor expressions like `interval(...)` to create
+    *constants* of the given type, and for that we required that the
+    argument was a single atomic value. The result was that these
+    constructor expressions were really more like literals for the
+    corresponding types than "normal" expressions. While that's useful
+    internally, it's confusing to the user. This commits changes that
+    to support arbitrary expressions as arguments.
+
+    To make this change without loosing a way to create actual constants
+    (which we need at some places), we implement this in two stages: the
+    parser initially turns such `interval(...)` expressions into call
+    operators[1] that the types now define for each desired constructor. We
+    then extend the normalizer with a new constants folding pass that
+    turns the call expressions into constants if possible.
+
+    The new constant folder remains limited to the cases we need for
+    this use case, but we'll be able to expand that later to  more
+    general folding.
+
+  * Fix bug in cast from `real` to `interval`. (Robin Sommer, Corelight)
+
+  * Add anchors to FAQ items in docs [skip CI]. (Benjamin Bannier, Corelight)
+
 1.7.0-dev.53 | 2023-01-25 09:39:02 +0100
 
   * Add stringification to UnitContext. (Benjamin Bannier, Corelight)

VERSION

@@ -1 +1 @@
-1.7.0-dev.53
+1.7.0-dev.78

doc/autogen/types/error.rst

@@ -4,3 +4,9 @@
 
     Retrieves the textual description associated with the error.
 
+.. rubric:: Operators
+
+.. spicy:operator:: error::Call error error(string)
+
+    Creates an error with the given message.
+

doc/autogen/types/integer.rst

@@ -12,6 +12,70 @@
 
     Computes the bit-wise 'xor' of the two integers.
 
+.. spicy:operator:: integer::Call int<16> int16(int)
+
+    Creates a 16-bit signed integer value.
+
+.. spicy:operator:: integer::Call int<16> int16(uint)
+
+    Creates a 16-bit signed integer value.
+
+.. spicy:operator:: integer::Call int<32> int32(int)
+
+    Creates a 32-bit signed integer value.
+
+.. spicy:operator:: integer::Call int<32> int32(uint)
+
+    Creates a 32-bit signed integer value.
+
+.. spicy:operator:: integer::Call int<64> int64(int)
+
+    Creates a 64-bit signed integer value.
+
+.. spicy:operator:: integer::Call int<64> int64(uint)
+
+    Creates a 64-bit signed integer value.
+
+.. spicy:operator:: integer::Call int<8> int8(int)
+
+    Creates a 8-bit signed integer value.
+
+.. spicy:operator:: integer::Call int<8> int8(uint)
+
+    Creates a 8-bit signed integer value.
+
+.. spicy:operator:: integer::Call uint<16> uint16(int)
+
+    Creates a 16-bit unsigned integer value.
+
+.. spicy:operator:: integer::Call uint<16> uint16(uint)
+
+    Creates a 16-bit unsigned integer value.
+
+.. spicy:operator:: integer::Call uint<32> uint32(int)
+
+    Creates a 32-bit unsigned integer value.
+
+.. spicy:operator:: integer::Call uint<32> uint32(uint)
+
+    Creates a 32-bit unsigned integer value.
+
+.. spicy:operator:: integer::Call uint<64> uint64(int)
+
+    Creates a 64-bit unsigned integer value.
+
+.. spicy:operator:: integer::Call uint<64> uint64(uint)
+
+    Creates a 64-bit unsigned integer value.
+
+.. spicy:operator:: integer::Call uint<8> uint8(int)
+
+    Creates a 8-bit unsigned integer value.
+
+.. spicy:operator:: integer::Call uint<8> uint8(uint)
+
+    Creates a 8-bit unsigned integer value.
+
 .. spicy:operator:: integer::Cast bool cast<bool-type>(int)
 
     Converts the value to a boolean by comparing against zero
@@ -220,6 +284,10 @@
 
     Inverts the sign of the integer.
 
+.. spicy:operator:: integer::SignNeg int op:- t:uint op:
+
+    Inverts the sign of the integer.
+
 .. spicy:operator:: integer::Sum int t:int <sp> op:+ <sp> t:int
 
     Computes the sum of the integers.

doc/autogen/types/interval.rst

@@ -10,6 +10,28 @@
 
 .. rubric:: Operators
 
+.. spicy:operator:: interval::Call interval interval(int)
+
+    Creates an interval interpreting the argument as number of seconds.
+
+.. spicy:operator:: interval::Call interval interval(real)
+
+    Creates an interval interpreting the argument as number of seconds.
+
+.. spicy:operator:: interval::Call interval interval(uint)
+
+    Creates an interval interpreting the argument as number of seconds.
+
+.. spicy:operator:: interval::Call interval interval_ns(int)
+
+    Creates an interval interpreting the argument as number of
+    nanoseconds.
+
+.. spicy:operator:: interval::Call interval interval_ns(uint)
+
+    Creates an interval interpreting the argument as number of
+    nanoseconds.
+
 .. spicy:operator:: interval::Difference interval t:interval <sp> op:- <sp> t:interval
 
     Returns the difference of the intervals.

doc/autogen/types/port.rst

@@ -6,6 +6,10 @@
 
 .. rubric:: Operators
 
+.. spicy:operator:: port::Call port port(uint<16>, enum)
+
+    Creates a port instance.
+
 .. spicy:operator:: port::Equal bool t:port <sp> op:== <sp> t:port
 
     Compares two port values.

doc/autogen/types/stream.rst

@@ -38,6 +38,10 @@
 
     Returns an iterator to the beginning of the container's content.
 
+.. spicy:operator:: stream::Call stream stream(bytes)
+
+    Creates a stream instance preinitialized with the given data.
+
 .. spicy:operator:: stream::End <iterator> end(<container>)
 
     Returns an iterator to the end of the container's content.

doc/autogen/types/time.rst

@@ -12,6 +12,26 @@
 
 .. rubric:: Operators
 
+.. spicy:operator:: time::Call time time(int)
+
+    Creates an time interpreting the argument as number of seconds.
+
+.. spicy:operator:: time::Call time time(real)
+
+    Creates an time interpreting the argument as number of seconds.
+
+.. spicy:operator:: time::Call time time(uint)
+
+    Creates an time interpreting the argument as number of seconds.
+
+.. spicy:operator:: time::Call time time_ns(int)
+
+    Creates an time interpreting the argument as number of nanoseconds.
+
+.. spicy:operator:: time::Call time time_ns(uint)
+
+    Creates an time interpreting the argument as number of nanoseconds.
+
 .. spicy:operator:: time::Difference interval t:time <sp> op:- <sp> t:time
 
     Returns the difference of the times.

hilti/runtime/CMakeLists.txt

@@ -32,6 +32,7 @@ set(SOURCES
     src/library.cc
     src/logging.cc
     src/main.cc
+    src/safe-math.cc
     src/type-info.cc
     src/types/address.cc
     src/types/bytes.cc

hilti/runtime/include/safe-math.h

@@ -0,0 +1,19 @@
+// Copyright (c) 2020-2022 by the Zeek Project. See LICENSE for details.
+//
+// Wrapper around functionality from 3rdparty's safe-math that we need. This
+// needs to be in a separate implementation file because one cannot include
+// both SafeInt.h and safe-math.h at the same time.
+
+#pragma once
+
+#include <cstdint>
+
+namespace hilti::rt::integer {
+
+/**
+ * Negates an unsigned value, returning a signed value. Will through a
+ * `OutOfRange` if not possible.
+ */
+extern int64_t safe_negate(uint64_t x);
+
+} // namespace hilti::rt::integer

hilti/runtime/include/types/interval.h

@@ -31,7 +31,7 @@ class Interval {
      *
      * @param nsecs interval in nanoseconds.
      */
-    explicit Interval(hilti::rt::integer::safe<int64_t> nsecs, NanosecondTag /*unused*/) : _nsecs(nsecs) {}
+    explicit Interval(const hilti::rt::integer::safe<int64_t>& nsecs, NanosecondTag /*unused*/) : _nsecs(nsecs) {}
 
     /**
      * Constructs an interval from a double value.
@@ -73,9 +73,11 @@ class Interval {
     Interval operator+(const Interval& other) const { return Interval(_nsecs + other._nsecs, NanosecondTag()); }
     Interval operator-(const Interval& other) const { return Interval(_nsecs - other._nsecs, NanosecondTag()); }
 
-    Interval operator*(hilti::rt::integer::safe<std::int64_t> i) const { return Interval(_nsecs * i, NanosecondTag()); }
+    Interval operator*(const hilti::rt::integer::safe<std::int64_t>& i) const {
+        return Interval(_nsecs * i, NanosecondTag());
+    }
 
-    Interval operator*(hilti::rt::integer::safe<std::uint64_t> i) const {
+    Interval operator*(const hilti::rt::integer::safe<std::uint64_t>& i) const {
         return Interval(_nsecs * i.Ref(), NanosecondTag());
     }