removes the builtin function syntax

documentation/TUTORIAL-CI.md

@@ -51,9 +51,9 @@ produces additional messages that may be helpful. For example it warns
 you about deprecated language features:
 
 ```
-   len == trlc:len(str), warning "potato", len
-          ^^^^^^^^ legacy.rsl:9: warning: deprecated feature, please use function len instead
-Verified 1 model(s) and check(s) and found 1 warning(s)
+checks MyType {
+       ^^^^^^ enum-ok/checks.check:4: issue: move this check block into bar.rsl:1 [deprecated_feature]
+Processed 1 model, 1 check and 1 requirement file and found 1 warning
 ```
 
 ## Return code

documentation/architecture.md

@@ -313,10 +313,6 @@ Symbol_Table
    Builtin_Boolean
    Builtin_String
    Builtin_Markup_String
-   Builtin_Function trlc:len
-   Builtin_Function trlc:startswith
-   Builtin_Function trlc:endswith
-   Builtin_Function trlc:matches
    Builtin_Function len
    Builtin_Function startswith
    Builtin_Function endswith
@@ -860,7 +856,7 @@ same assumption about `normal_error_1`, any checks under
 We model types as follows
 
 | TRLC Type        | PyVCG Sort      | SMTLIB Sort |
-|------------------|-----------------|-------------|
+| ---------------- | --------------- | ----------- |
 | Builtin_Boolean  | BUILTIN_BOOLEAN | Bool        |
 | Builtin_Integer  | BUILTIN_INTEGER | Int         |
 | Builtin_Decimal  | BUILTIN_REAL    | Real        |

language-reference-manual/lrm.trlc

@@ -78,13 +78,6 @@ section "Lexing" {
                   "Kitten_Exploder"]
     }
 
-    Terminal Builtin_Identifier {
-      text = '''There is also a legacy "builtin" identifier that is
-                deprecated. It will be removed in a future major release.'''
-      def = "BUILTIN_IDENTIFIER ::= [a-z]+:[a-zA-Z][a-zA-Z0-9_]*"
-      examples = ["trlc:len"]
-    }
-
     Keywords TRLC_Keywords {
       text = '''A keyword is an identifier that is one of the following
                 reserved words:'''
@@ -1105,7 +1098,6 @@ section "Names" {
   Grammar Names {
     bnf = '''
       name ::= qualified_name
-             | BUILTIN_IDENTIFIER
              | name '.' IDENTIFIER
              | name '[' expression ']'
              | name '(' parameter_list ')'
@@ -1116,8 +1108,6 @@ section "Names" {
     bullets = [
       '''A qualified name referring to either some object, a component
          (in a record) or field (in a tuple), or an enumeration type.''',
-      '''(Deprecated) A builtin identifier for an old-style
-         builtin function.''',
       '''A tuple field or enumeration literal.''',
       '''An index into an array.''',
       '''A (builtin) function call.'''

tests-unit/test_lexer.py

@@ -84,12 +84,6 @@ def testIdentifiers2(self):
         self.match("IDENTIFIER", "b4r")
 
     def testIdentifiers3(self):
-        # lobster-trace: LRM.Builtin_Identifier
-        with self.assertRaises(TRLC_Error):
-            self.input("foo:bar")
-        self.matchError("builtin function name must start with trlc:")
-
-    def testIdentifiers4(self):
         # lobster-trace: LRM.Identifier
         with self.assertRaises(TRLC_Error):
             self.input("_foo_")

trlc/ast.py

@@ -154,10 +154,6 @@ def dump(self, indent=0):  # pragma: no cover
                      Record_Object SomeThing
                         Type: MyType
                         Field description: "Potato"
-               Builtin_Function trlc:endswith
-               Builtin_Function trlc:len
-               Builtin_Function trlc:matches
-               Builtin_Function trlc:startswith
                Builtin_Function endswith
                Builtin_Function len
                Builtin_Function matches
@@ -2199,9 +2195,6 @@ class Builtin_Function(Entity):
     :attribute arity: number of parameters
     :type: int
 
-    :attribute deprecated: if this functions is deprecated and should no \
-    longer be used
-    :type: bool
     """
     LOCATION = Location(file_name = "<builtin>")
 
@@ -2210,7 +2203,6 @@ def __init__(self, name, arity):
         assert isinstance(arity, int)
         assert arity >= 0
         self.arity = arity
-        self.deprecated = ":" in name
 
     def dump(self, indent=0):  # pragma: no cover
         self.write_indent(indent, self.__class__.__name__ + " " + self.name)
@@ -3219,15 +3211,6 @@ def create_global_table(cls, mh):
         stab.register(mh, Builtin_Boolean())
         stab.register(mh, Builtin_String())
         stab.register(mh, Builtin_Markup_String())
-        # The legacy versions
-        stab.register(mh,
-                      Builtin_Function("trlc:len", 1))
-        stab.register(mh,
-                      Builtin_Function("trlc:startswith", 2))
-        stab.register(mh,
-                      Builtin_Function("trlc:endswith", 2))
-        stab.register(mh,
-                      Builtin_Function("trlc:matches", 2))
 
         # The new-style functions
         stab.register(mh,

trlc/lexer.py

@@ -137,7 +137,6 @@ class Token(Token_Base):
     KIND = {
         "COMMENT"    : "comment",
         "IDENTIFIER" : "identifier",
-        "BUILTIN"    : "bultin identifier",
         "KEYWORD"    : "keyword",
         "BRA"        : "opening parenthesis '('",
         "KET"        : "closing parenthesis ')'",
@@ -161,7 +160,7 @@ class Token(Token_Base):
 
     def __init__(self, location, kind, value=None):
         assert kind in Token.KIND
-        if kind in ("COMMENT", "IDENTIFIER", "BUILTIN",
+        if kind in ("COMMENT", "IDENTIFIER",
                     "KEYWORD", "OPERATOR", "STRING"):
             assert isinstance(value, str)
         elif kind == "INTEGER":
@@ -200,7 +199,6 @@ def __init__(self, mh, content):
     @staticmethod
     def is_alpha(char):
         # lobster-trace: LRM.Identifier
-        # lobster-trace: LRM.Builtin_Identifier
         return char.isascii() and char.isalpha()
 
     @staticmethod
@@ -212,7 +210,6 @@ def is_numeric(char):
     @staticmethod
     def is_alnum(char):
         # lobster-trace: LRM.Identifier
-        # lobster-trace: LRM.Builtin_Identifier
         return char.isascii() and char.isalnum()
 
     @abstractmethod
@@ -591,13 +588,6 @@ def token(self):
             if value in TRLC_Lexer.KEYWORDS:
                 # lobster-trace: LRM.TRLC_Keywords
                 kind = "KEYWORD"
-            elif ":" in value:
-                # lobster-trace: LRM.Builtin_Identifier
-                kind = "BUILTIN"
-                if not value.startswith("trlc:"):
-                    self.mh.lex_error(sref,
-                                      "builtin function name must start "
-                                      "with trlc:")
 
         elif kind == "OPERATOR":
             value = sref.text()

trlc/parser.py

@@ -1025,15 +1025,6 @@ def parse_builtin(self, scope, n_name, t_name):
                                    ast.Builtin_Numeric_Type))
         assert isinstance(t_name, Token)
 
-        # Lint: complain about old functions
-        if isinstance(n_name, ast.Builtin_Function) and \
-           self.lint_mode and n_name.deprecated:
-            self.mh.check(
-                t_name.location,
-                "please use function %s instead" %
-                n_name.name.replace("trlc:", ""),
-                "deprecated_feature")
-
         # Parse the arguments.
         parameters = []
         self.match("BRA")
@@ -1056,7 +1047,7 @@ def parse_builtin(self, scope, n_name, t_name):
                           n_name.arity)
 
         # Enforce types
-        if n_name.name in ("len", "trlc:len"):
+        if n_name.name == "len":
             if isinstance(parameters[0].typ, ast.Builtin_String):
                 return ast.Unary_Expression(
                     mh        = self.mh,
@@ -1073,9 +1064,7 @@ def parse_builtin(self, scope, n_name, t_name):
                     n_operand = parameters[0])
 
         elif n_name.name in ("startswith",
-                             "endswith",
-                             "trlc:startswith",
-                             "trlc:endswith"):
+                             "endswith"):
             return ast.Binary_Expression(
                 mh       = self.mh,
                 location = t_name.location,
@@ -1086,7 +1075,7 @@ def parse_builtin(self, scope, n_name, t_name):
                 n_lhs    = parameters[0],
                 n_rhs    = parameters[1])
 
-        elif n_name.name in ("matches", "trlc:matches"):
+        elif n_name.name == "matches":
             parameters[1].ensure_type(self.mh, ast.Builtin_String)
             try:
                 # scope is None on purpose to enforce static context
@@ -1134,7 +1123,6 @@ def parse_name(self, scope):
         # qualified_name ::= [ IDENTIFIER_package_name '.' ] IDENTIFIER_name
         #
         # name ::= qualified_name
-        #        | BUILTIN_IDENTIFIER
         #        | name '.' IDENTIFIER
         #        | name '[' expression ']'
         #        | name '(' parameter_list ')'
@@ -1150,21 +1138,13 @@ def parse_name(self, scope):
         # components the true grammar for function calls is always
         # IDENTIFIER '('; so we can slightly special case this.
 
-        if self.peek("BUILTIN"):
-            # Legacy builtin function call. The lookup in the root
-            # scope is not an error.
-            # lobster-trace: LRM.Builtin_Functions
-            self.match("BUILTIN")
-            n_name = self.stab.lookup(self.mh, self.ct, ast.Builtin_Function)
-
-        else:
+        if self.peek("IDENTIFIER"):
             # lobster-trace: LRM.Builtin_Functions
             # lobster-trace: LRM.Builtin_Type_Conversion_Functions
             self.match("IDENTIFIER")
             if self.peek("BRA"):
-                # There is one more way we can have a builtin
-                # function, if we follow our name with brackets
-                # immediately.
+                # If we follow our name with brackets
+                # immediately, we have a builtin function call.
                 n_name = self.stab.lookup(self.mh,
                                           self.ct)
                 if not isinstance(n_name, (ast.Builtin_Function,
@@ -1175,7 +1155,7 @@ def parse_name(self, scope):
             else:
                 n_name = self.parse_qualified_name(scope, match_ident=False)
 
-        # Enum literals are a bit different, so we deal with themq
+        # Enum literals are a bit different, so we deal with them
         # first.
         if isinstance(n_name, ast.Enumeration_Type):
             self.match("DOT")