Support detailed analysis for fts5 functions

analysis_options.yaml

@@ -12,75 +12,162 @@ analyzer:
     # Will be analyzed anyway, nobody knows why ¯\_(ツ)_/¯. We're only analyzing lib/ and test/ as a workaround
     - ".dart_tool/build/entrypoint/build.dart"
     - "tool/**"
+
+# this should always include all rules. Those we don't use are commented out
 linter:
   rules:
-    - annotate_overrides
+    # ERROR RULES
     - avoid_empty_else
-    - avoid_function_literals_in_foreach_calls
-    - avoid_init_to_null
-    - avoid_null_checks_in_equality_operators
+    #    - avoid_print (all our prints can be turned off)
     - avoid_relative_lib_imports
+    - avoid_returning_null_for_future
+    #    - avoid_slow_async_io
+    - avoid_types_as_parameter_names
+    - cancel_subscriptions
+    - close_sinks
+    - comment_references
+    - control_flow_in_finally
+    #    - diagnostic_describe_all_properties (Flutter-specific, not relevant for us)
+    - empty_statements
+    - hash_and_equals
+    #    - invariant_booleans (turned off because the lint rule is buggy)
+    - iterable_contains_unrelated_type
+    - list_remove_unrelated_type
+    - literal_only_boolean_expressions
+    - no_adjacent_strings_in_list
+    - no_duplicate_case_values
+    #   - prefer_relative_imports (clashes with avoid_relative_lib_imports)
+    #    - prefer_void_to_null (we do use Null as a type for alwaysThrows functions)
+    - test_types_in_equals
+    - throw_in_finally
+    - unnecessary_statements
+    - unrelated_type_equality_checks
+    - unsafe_html
+    - valid_regexps
+    # STYLE RULES
+    - always_declare_return_types
+    #    - always_put_control_body_on_new_line (we don't do this if it fits on the same line)
+    #    - always_put_required_named_parameters_first (we just don't do this)
+    #    - always_require_non_null_named_parameters (we don't use assert foo != null for parameters)
+    #    - always_specify_types (we prefer to omit the type parameter when possible)
+    - annotate_overrides
+    #    - avoid_annotating_with_dynamic (we prefer to make dynamic explicit)
+    #    - avoid_as (we prefer to make explicit casts explicit!)
+    - avoid_bool_literals_in_conditional_expressions
+    #    - avoid_catches_without_on_clauses (we have a lot of generic catches)
+    - avoid_catching_errors
+    - avoid_classes_with_only_static_members
+    - avoid_double_and_int_checks
+    #    - avoid_equals_and_hash_code_on_mutable_classes (lint is to generic for transient fields)
+    - avoid_field_initializers_in_const_classes
+    - avoid_function_literals_in_foreach_calls
+    #    - avoid_implementing_value_types (maybe we can consider turning this on?)
+    - avoid_init_to_null
+    - avoid_js_rounded_ints
+    - avoid_null_checks_in_equality_operators
+    #    - avoid_positional_boolean_parameters (there pretty useful when there's only one boolean param)
+    #    - avoid_private_typedef_functions (they're still useful)
+    - avoid_renaming_method_parameters
     - avoid_return_types_on_setters
     - avoid_returning_null
-    - avoid_types_as_parameter_names
+    - avoid_returning_null_for_void
+    - avoid_returning_this
+    - avoid_setters_without_getters
+    - avoid_shadowing_type_parameters
+    - avoid_single_cascade_in_expression_statements
+    #    - avoid_types_on_closure_parameters (the interference isn't THAT good)
+    #    - avoid_unnecessary_containers (Flutter-specific, not relevant here)
     - avoid_unused_constructor_parameters
+    - avoid_void_async
     - await_only_futures
+    - camel_case_extensions
     - camel_case_types
-    - cancel_subscriptions
-    - comment_references
+    #    - cascade_invocations (sometimes the explicit notation is more readable)
     - constant_identifier_names
     - curly_braces_in_flow_control_structures
-    - control_flow_in_finally
     - directives_ordering
     - empty_catches
     - empty_constructor_bodies
-    - empty_statements
-    - hash_and_equals
+    - file_names
+    #    - flutter_style_todos (Flutter-development specific, not relevant here)
     - implementation_imports
-    - invariant_booleans
-    - iterable_contains_unrelated_type
+    - join_return_with_assignment
     - library_names
     - library_prefixes
-    - list_remove_unrelated_type
-    - no_adjacent_strings_in_list
-    - no_duplicate_case_values
+    - lines_longer_than_80_chars
     - non_constant_identifier_names
     - null_closures
     - omit_local_variable_types
+    #    - one_member_abstracts (there are cases where a one-member abstract class makes sense, see moor's Insertable)
     - only_throw_errors
     - overridden_fields
     - package_api_docs
-    - package_names
-    - package_prefixed_library_names
+    #    - package_prefixed_library_names (this isn't java)
+    #    - parameter_assignments (we regularly use this to set default values)
     - prefer_adjacent_string_concatenation
+    - prefer_asserts_in_initializer_lists
+    #    - prefer_asserts_with_message (it's annoying to write messages for internal invariants)
     - prefer_collection_literals
     - prefer_conditional_assignment
     - prefer_const_constructors
+    - prefer_const_constructors_in_immutables
+    - prefer_const_declarations
+    - prefer_const_literals_to_create_immutables
+    - prefer_constructors_over_static_methods
     - prefer_contains
+    #    - prefer_double_quotes (we prefer single quotes)
     - prefer_equal_for_default_values
+    #    - prefer_expression_function_bodies (for multiline expressions, this is ugly to format)
     - prefer_final_fields
+    - prefer_final_in_for_each
     - prefer_final_locals
+    - prefer_for_elements_to_map_fromIterable
+    - prefer_foreach
+    - prefer_function_declarations_over_variables
+    - prefer_generic_function_type_aliases
+    - prefer_if_elements_to_conditional_expressions
+    - prefer_if_null_operators
     - prefer_initializing_formals
+    - prefer_inlined_adds
+    - prefer_int_literals
     - prefer_interpolation_to_compose_strings
     - prefer_is_empty
     - prefer_is_not_empty
+    - prefer_is_not_operator
+    - prefer_iterable_whereType
+    #    - prefer_mixin (todo we could consider enabling this)
+    - prefer_null_aware_operators
     - prefer_single_quotes
+    - prefer_spread_collections
     - prefer_typing_uninitialized_variables
+    - provide_deprecation_message
+    - public_member_api_docs
     - recursive_getters
     - slash_for_doc_comments
-    - test_types_in_equals
-    - throw_in_finally
+    #    - sort_child_properties_last (Flutter specific)
+    #    - sort_constructors_first (we don't do this)
+    #    - sort_unnamed_constructors_first
+    - type_annotate_public_apis
     - type_init_formals
     - unawaited_futures
     - unnecessary_brace_in_string_interps
+    - unnecessary_const
+    #    - unnecessary_final (we prefer final here)
     - unnecessary_getters_setters
     - unnecessary_lambdas
     - unnecessary_new
-    - unnecessary_const
     - unnecessary_null_aware_assignments
-    - unnecessary_statements
+    - unnecessary_null_in_if_null_operators
+    - unnecessary_overrides
+    - unnecessary_parenthesis
     - unnecessary_this
-    - unrelated_type_equality_checks
+    #    - use_full_hex_values_for_flutter_colors (Flutter specific)
+    - use_function_type_syntax_for_parameters
     - use_rethrow_when_possible
-    - valid_regexps
-    - public_member_api_docs
+    - use_setters_to_change_properties
+    - use_string_buffers
+    #    - use_to_and_as_if_applicable (false positive on operators)
+    - void_checks
+    # PUB RULES
+    - package_names
+#   - sort_pub_dependencies (we prefer to group them by what they do)

moor_generator/lib/src/analyzer/dart/column_parser.dart

@@ -49,7 +49,7 @@ class ColumnParser {
   SpecifiedColumn parse(MethodDeclaration getter, Element element) {
     final expr = base.returnExpressionOfMethod(getter);
 
-    if (!(expr is FunctionExpressionInvocation)) {
+    if (expr is! FunctionExpressionInvocation) {
       base.step.reportError(ErrorInDartCode(
         affectedElement: getter.declaredElement,
         message: _errorMessage,

moor_generator/lib/src/analyzer/dart/parser.dart

@@ -1,8 +1,8 @@
 import 'package:analyzer/dart/analysis/results.dart';
-import 'package:analyzer/dart/element/type.dart';
-import 'package:meta/meta.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:meta/meta.dart';
 import 'package:moor/sqlite_keywords.dart';
 import 'package:moor_generator/src/analyzer/errors.dart';
 import 'package:moor_generator/src/analyzer/runner/steps.dart';
@@ -45,7 +45,7 @@ class MoorDartParser {
   Expression returnExpressionOfMethod(MethodDeclaration method) {
     final body = method.body;
 
-    if (!(body is ExpressionFunctionBody)) {
+    if (body is! ExpressionFunctionBody) {
       step.reportError(ErrorInDartCode(
         affectedElement: method.declaredElement,
         severity: Severity.criticalError,
@@ -67,7 +67,7 @@ class MoorDartParser {
   }
 
   String readStringLiteral(Expression expression, void Function() onError) {
-    if (!(expression is StringLiteral)) {
+    if (expression is! StringLiteral) {
       onError();
     } else {
       final value = (expression as StringLiteral).stringValue;
@@ -82,7 +82,7 @@ class MoorDartParser {
   }
 
   int readIntLiteral(Expression expression, void Function() onError) {
-    if (!(expression is IntegerLiteral)) {
+    if (expression is! IntegerLiteral) {
       onError();
       // ignore: avoid_returning_null
       return null;

moor_generator/lib/src/analyzer/moor/create_table_reader.dart

@@ -22,9 +22,7 @@ class CreateTableReader {
     final foundColumns = <String, SpecifiedColumn>{};
     final primaryKey = <SpecifiedColumn>{};
 
-    for (final column in table.resolvedColumns) {
-      if (!column.includedInResults) continue;
-
+    for (final column in table.resultColumns) {
       var isPrimaryKey = false;
       final features = <ColumnFeature>[];
       final sqlName = column.name;

sqlparser/lib/src/analysis/analysis.dart

@@ -7,20 +7,18 @@ import 'package:sqlparser/src/engine/options.dart';
 import 'package:sqlparser/src/reader/tokenizer/token.dart';
 import 'package:sqlparser/src/utils/meta.dart';
 
+part 'context.dart';
+part 'error.dart';
 part 'schema/column.dart';
 part 'schema/from_create_table.dart';
 part 'schema/references.dart';
 part 'schema/table.dart';
-
 part 'steps/column_resolver.dart';
+part 'steps/linting_visitor.dart';
 part 'steps/prepare_ast.dart';
 part 'steps/reference_resolver.dart';
 part 'steps/set_parent_visitor.dart';
 part 'steps/type_resolver.dart';
-
 part 'types/data.dart';
 part 'types/resolver.dart';
 part 'types/typeable.dart';
-
-part 'error.dart';
-part 'context.dart';

sqlparser/lib/src/analysis/context.dart

@@ -16,11 +16,12 @@ class AnalysisContext {
   /// A resolver that can be used to obtain the type of a [Typeable]. This
   /// mostly applies to [Expression]s, [Reference]s, [Variable]s and
   /// [ResultSet.resolvedColumns] of a select statement.
-  final TypeResolver types;
+  /* late final */ TypeResolver types;
 
   /// Constructs a new analysis context from the AST and the source sql.
-  AnalysisContext(this.root, this.sql, EngineOptions options)
-      : types = TypeResolver(options);
+  AnalysisContext(this.root, this.sql, EngineOptions options) {
+    types = TypeResolver(this, options);
+  }
 
   /// Reports an analysis error.
   void reportError(AnalysisError error) {

sqlparser/lib/src/analysis/schema/table.dart

@@ -34,6 +34,11 @@ class Table with ResultSet, VisibleToChildren, HasMetaMixin {
   @override
   final List<TableColumn> resolvedColumns;
 
+  /// Filter the [resolvedColumns] for those that are
+  /// [Column.includedInResults].
+  List<TableColumn> get resultColumns =>
+      resolvedColumns.where((c) => c.includedInResults).toList();
+
   /// Whether this table was created with an "WITHOUT ROWID" modifier
   final bool withoutRowId;
 

sqlparser/lib/src/analysis/steps/linting_visitor.dart

@@ -0,0 +1,25 @@
+part of '../analysis.dart';
+
+/// Visitor that runs after all other steps ran and reports more complex lints
+/// on an sql statement.
+class LintingVisitor extends RecursiveVisitor<void> {
+  final EngineOptions options;
+  final AnalysisContext context;
+
+  LintingVisitor(this.options, this.context);
+
+  @override
+  void visitAggregateExpression(Invocation e) => _visitInvocation(e);
+
+  @override
+  void visitFunction(Invocation e) => _visitInvocation(e);
+
+  void _visitInvocation(Invocation e) {
+    final lowercaseCall = e.name.toLowerCase();
+    if (options.addedFunctions.containsKey(lowercaseCall)) {
+      options.addedFunctions[lowercaseCall].reportErrors(e, context);
+    }
+
+    visitChildren(e);
+  }
+}

sqlparser/lib/src/analysis/types/resolver.dart

@@ -15,9 +15,10 @@ const _comparisonOperators = [
 
 class TypeResolver {
   final Map<Typeable, ResolveResult> _results = {};
+  final AnalysisContext context;
   final EngineOptions options;
 
-  TypeResolver(this.options);
+  TypeResolver(this.context, this.options);
 
   ResolveResult _cache<T extends Typeable>(
       ResolveResult Function(T param) resolver, T typeable) {
@@ -188,7 +189,8 @@ class TypeResolver {
           parameters.isEmpty ? false : justResolve(parameters.first).nullable;
       final anyNullable = parameters.map(justResolve).any((r) => r.nullable);
 
-      switch (call.name.toLowerCase()) {
+      final lowercaseName = call.name.toLowerCase();
+      switch (lowercaseName) {
         case 'round':
           // if there is only one param, returns an int. otherwise real
           if (parameters.length == 1) {
@@ -317,13 +319,18 @@ class TypeResolver {
         }
       }
 
+      if (options.addedFunctions.containsKey(lowercaseName)) {
+        return options.addedFunctions[lowercaseName]
+            .inferReturnType(this, call, parameters);
+      }
+
       throw StateError('Unknown function: ${call.name}');
     }, call);
   }
 
   ResolveResult _resolveFunctionArgument(
       Invocation parent, Expression argument) {
-    return _cache((argument) {
+    return _cache<Expression>((argument) {
       final functionName = parent.name.toLowerCase();
       final args = _expandParameters(parent);
 
@@ -333,6 +340,12 @@ class TypeResolver {
           argument == args[1]) {
         return const ResolveResult(ResolvedType(type: BasicType.int));
       }
+
+      if (options.addedFunctions.containsKey(functionName)) {
+        return options.addedFunctions[functionName]
+            .inferArgumentType(this, parent, argument);
+      }
+
       return const ResolveResult.unknown();
     }, argument);
   }
@@ -442,7 +455,7 @@ class ResolveResult {
   final ResolvedType type;
 
   /// Whether more context is needed to resolve the type. Used internally by the
-  /// analyze.
+  /// analyzer.
   final bool needsContext;
 
   /// Whether type resolution failed.

sqlparser/lib/src/ast/expressions/function.dart

@@ -2,6 +2,8 @@ part of '../ast.dart';
 
 /// Interface for function calls, either a [FunctionExpression] or a
 /// [AggregateExpression].
+// todo: How does this not clash with Invocation from dart:core :O Anyway, we
+// might want to consider renaming.
 abstract class Invocation extends Expression {
   /// The name of the function being called
   String get name;

sqlparser/lib/src/engine/module/fts5.dart

@@ -7,6 +7,7 @@ class Fts5Extension implements Extension {
   @override
   void register(SqlEngine engine) {
     engine.registerModule(_Fts5Module());
+    engine.registerFunctionHandler(const _Fts5Functions());
   }
 }
 
@@ -51,6 +52,111 @@ class _Fts5Table extends Table {
         );
 }
 
+/// Provides type inference and lints for
+class _Fts5Functions implements FunctionHandler {
+  const _Fts5Functions();
+
+  @override
+  Set<String> get functionNames => const {'bm25', 'highlight', 'snippet'};
+
+  @override
+  ResolveResult inferArgumentType(
+      TypeResolver resolver, Invocation call, Expression argument) {
+    int argumentIndex;
+    if (call.parameters is ExprFunctionParameters) {
+      argumentIndex = (call.parameters as ExprFunctionParameters)
+          .parameters
+          .indexOf(argument);
+    }
+    if (argumentIndex == null || argumentIndex < 0) {
+      // couldn't find expression in arguments, so we don't know the type
+      return const ResolveResult.unknown();
+    }
+
+    switch (call.name) {
+      case 'bm25':
+        // bm25(fts_table)
+        return const ResolveResult.unknown();
+      case 'highlight':
+        // highlight(fts_table, column_index, text_before, text_after)
+        if (argumentIndex == 1) {
+          return const ResolveResult(ResolvedType(type: BasicType.int));
+        } else if (argumentIndex == 2 || argumentIndex == 3) {
+          return const ResolveResult(ResolvedType(type: BasicType.text));
+        }
+        break;
+      case 'snippet':
+        // snippet(fts_table, column_index, phrase_before, phrase_after,
+        //         text_before, max_tokens)
+        if (argumentIndex == 1 || argumentIndex == 5) {
+          return const ResolveResult(ResolvedType(type: BasicType.int));
+        } else if (argumentIndex >= 2 || argumentIndex <= 4) {
+          return const ResolveResult(ResolvedType(type: BasicType.text));
+        }
+        break;
+    }
+    return const ResolveResult.unknown();
+  }
+
+  @override
+  ResolveResult inferReturnType(
+      TypeResolver resolver, Invocation call, List<Typeable> expandedArgs) {
+    switch (call.name) {
+      case 'bm25':
+        return const ResolveResult(ResolvedType(type: BasicType.real));
+      case 'highlight':
+        return const ResolveResult(ResolvedType(type: BasicType.text));
+      case 'snippet':
+        return const ResolveResult(ResolvedType(type: BasicType.text));
+    }
+    return const ResolveResult.unknown();
+  }
+
+  @override
+  void reportErrors(Invocation call, AnalysisContext context) {
+    // it doesn't make sense to call fts5 functions with a star parameter
+    if (call.parameters is StarFunctionParameter) {
+      context.reportError(AnalysisError(
+        relevantNode: call,
+        message: '${call.name} should not be called with a star parameter',
+        type: AnalysisErrorType.other,
+      ));
+      return;
+    }
+
+    final args = (call.parameters as ExprFunctionParameters).parameters;
+    final expectedArgCount = const {
+      'bm25': 1,
+      'highlight': 4,
+      'snippet': 6,
+    }[call.name.toLowerCase()];
+
+    if (expectedArgCount != args.length) {
+      context.reportError(AnalysisError(
+        relevantNode: call,
+        message: '${call.name} expects $expectedArgCount arguments, '
+            'got ${args.length}.',
+        type: AnalysisErrorType.other,
+      ));
+      return;
+    }
+
+    Column firstResolved;
+    if (args.first is Reference) {
+      firstResolved = (args.first as Reference).resolvedColumn;
+    }
+
+    // the first argument to all functions must be a fts5 table name
+    if (firstResolved == null || firstResolved is! _Fts5TableColumn) {
+      context.reportError(AnalysisError(
+        relevantNode: args.first,
+        message: 'Expected an fts5 table name here',
+        type: AnalysisErrorType.other,
+      ));
+    }
+  }
+}
+
 /// The rank column, which we introduce to support queries like
 /// ```
 /// SELECT * FROM my_fts_table WHERE my_fts_table MATCH 'foo' ORDER BY rank;

sqlparser/lib/src/engine/module/module.dart

@@ -8,6 +8,45 @@ abstract class Extension {
   void register(SqlEngine engine);
 }
 
+/// Function handlers can be implemented by an [Extension] to add type analysis
+/// for additional function.
+abstract class FunctionHandler {
+  /// The set of function names supported by this handler.
+  ///
+  /// The returned set shouldn't change over time.
+  Set<String> get functionNames;
+
+  /// Resolve the return type of a function invocation.
+  ///
+  /// The [call] refers to a function declared in [functionNames]. To provide
+  /// further analysis, the [resolver] may be used. To support function calls
+  /// with a [StarFunctionParameter], [expandedArgs] contains the expanded
+  /// arguments from a `function(*)` call.
+  ///
+  /// If resolving to a type isn't possible, implementations should return
+  /// [ResolveResult.unknown].
+  ResolveResult inferReturnType(
+      TypeResolver resolver, Invocation call, List<Typeable> expandedArgs);
+
+  /// Resolve the type of an argument used in a function invocation.
+  ///
+  /// The [call] refers to a function declared in [functionNames]. To provide
+  /// further analysis, the [resolver] may be used. This method should return
+  /// the inferred type of [argument], which is an argument passed to the
+  /// [call].
+  ///
+  /// If resolving to a type isn't possible, implementations should return
+  /// [ResolveResult.unknown].
+  ResolveResult inferArgumentType(
+      TypeResolver resolver, Invocation call, Expression argument);
+
+  /// Can optionally be used by implementations to provide [AnalysisError]s
+  /// from the [call].
+  ///
+  /// Errors should be reported via [AnalysisContext.reportError].
+  void reportErrors(Invocation call, AnalysisContext context) {}
+}
+
 /// An sqlite module, which can be used in a `CREATE VIRTUAL TABLE` statement
 /// to find providers.
 abstract class Module implements Referencable, VisibleToChildren {

sqlparser/lib/src/engine/options.dart

@@ -1,3 +1,5 @@
+import 'package:sqlparser/sqlparser.dart';
+
 class EngineOptions {
   /// Moor extends the sql grammar a bit to support type converters and other
   /// features. Enabling this flag will make this engine parse sql with these
@@ -7,5 +9,20 @@ class EngineOptions {
   /// Enables functions declared in the `json1` module for analysis
   final bool enableJson1;
 
-  EngineOptions(this.useMoorExtensions, this.enableJson1);
+  /// All [Extension]s that have been enabled in this sql engine.
+  final List<Extension> enabledExtensions;
+
+  final List<FunctionHandler> _addedFunctionHandlers = [];
+  final Map<String, FunctionHandler> addedFunctions = {};
+
+  EngineOptions(
+      this.useMoorExtensions, this.enableJson1, this.enabledExtensions);
+
+  void addFunctionHandler(FunctionHandler handler) {
+    _addedFunctionHandlers.add(handler);
+
+    for (final function in handler.functionNames) {
+      addedFunctions[function.toLowerCase()] = handler;
+    }
+  }
 }

sqlparser/lib/src/engine/sql_engine.dart

@@ -22,9 +22,12 @@ class SqlEngine {
       {bool useMoorExtensions = false,
       bool enableJson1Module = false,
       bool enableFts5 = false})
-      : options = EngineOptions(useMoorExtensions, enableJson1Module) {
-    if (enableFts5) {
-      const Fts5Extension().register(this);
+      : options = _constructOptions(
+            moor: useMoorExtensions,
+            json1: enableJson1Module,
+            fts5: enableFts5) {
+    for (final extension in options.enabledExtensions) {
+      extension.register(this);
     }
 
     registerTable(sqliteMaster);
@@ -37,10 +40,19 @@ class SqlEngine {
     knownTables.add(table);
   }
 
+  /// Registers the [module], which means that it can be used as a function in
+  /// `CREATE VIRTUAL TABLE` statements.
   void registerModule(Module module) {
     _knownModules.add(module);
   }
 
+  /// Registers the [handler], which can provide implementations for additional
+  /// sql functions that can then be used in statements analyzed through this
+  /// engine.
+  void registerFunctionHandler(FunctionHandler handler) {
+    options.addFunctionHandler(handler);
+  }
+
   ReferenceScope _constructRootScope({ReferenceScope parent}) {
     final scope = parent == null ? ReferenceScope(null) : parent.createChild();
     for (final table in knownTables) {
@@ -152,7 +164,8 @@ class SqlEngine {
         node
           ..accept(ColumnResolver(context))
           ..accept(ReferenceResolver(context))
-          ..accept(TypeResolvingVisitor(context));
+          ..accept(TypeResolvingVisitor(context))
+          ..accept(LintingVisitor(options, context));
       }
     } catch (_) {
       rethrow;
@@ -168,6 +181,13 @@ class SqlEngine {
 
     root.scope = _constructRootScope(parent: safeScope);
   }
+
+  static EngineOptions _constructOptions({bool moor, bool fts5, bool json1}) {
+    final extensions = [
+      if (fts5) const Fts5Extension(),
+    ];
+    return EngineOptions(moor, json1, extensions);
+  }
 }
 
 /// The result of parsing an sql query. Contains the root of the AST and all

sqlparser/test/engine/module/fts5_test.dart

@@ -2,28 +2,162 @@ import 'package:sqlparser/sqlparser.dart';
 import 'package:test/test.dart';
 
 void main() {
-  test('can create fts5 tables', () {
+  group('creating fts5 tables', () {
     final engine = SqlEngine(enableFts5: true);
-    final result = engine.analyze(
-        "CREATE VIRTUAL TABLE foo USING fts5(bar , tokenize = 'porter ascii')");
 
-    final table =
-        SchemaFromCreateTable().read(result.root as TableInducingStatement);
+    test('can create fts5 tables', () {
+      final result = engine.analyze('CREATE VIRTUAL TABLE foo USING '
+          "fts5(bar , tokenize = 'porter ascii')");
 
-    expect(table.name, 'foo');
-    expect(table.resolvedColumns, hasLength(1));
-    expect(table.resolvedColumns.single.name, 'bar');
+      final table =
+          SchemaFromCreateTable().read(result.root as TableInducingStatement);
+
+      expect(table.name, 'foo');
+      final columns = table.resultColumns;
+      expect(columns, hasLength(1));
+      expect(columns.single.name, 'bar');
+    });
+
+    test('handles the UNINDEXED column option', () {
+      final result = engine
+          .analyze('CREATE VIRTUAL TABLE foo USING fts5(bar, baz UNINDEXED)');
+
+      final table =
+          SchemaFromCreateTable().read(result.root as TableInducingStatement);
+
+      expect(table.name, 'foo');
+      expect(table.resultColumns.map((c) => c.name), ['bar', 'baz']);
+    });
   });
 
-  test('handles the UNINDEXED column option', () {
-    final engine = SqlEngine(enableFts5: true);
-    final result = engine
-        .analyze('CREATE VIRTUAL TABLE foo USING fts5(bar, baz UNINDEXED)');
+  group('type inference for function calls', () {
+    SqlEngine engine;
+    setUp(() {
+      engine = SqlEngine(enableFts5: true);
+      // add an fts5 table for the following queries
+      final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING '
+          'fts5(bar, baz);');
+      engine.registerTable(SchemaFromCreateTable()
+          .read(fts5Result.root as TableInducingStatement));
+    });
 
-    final table =
-        SchemaFromCreateTable().read(result.root as TableInducingStatement);
+    test('return type of bm25()', () {
+      final result = engine
+          .analyze('SELECT *, bm25(foo) AS b FROM foo WHERE foo MATCH \'\'');
 
-    expect(table.name, 'foo');
-    expect(table.resolvedColumns.map((c) => c.name), ['bar', 'baz']);
+      final select = result.root as SelectStatement;
+      final column = select.resolvedColumns.singleWhere((c) => c.name == 'b');
+      expect(result.typeOf(column),
+          const ResolveResult(ResolvedType(type: BasicType.real)));
+    });
+
+    test('return type of highlight()', () {
+      final result =
+          engine.analyze("SELECT *, highlight(foo, 0, '<b>', '</b>') AS b "
+              "FROM foo WHERE foo MATCH ''");
+
+      final select = result.root as SelectStatement;
+      final column = select.resolvedColumns.singleWhere((c) => c.name == 'b');
+      expect(result.typeOf(column),
+          const ResolveResult(ResolvedType(type: BasicType.text)));
+    });
+
+    test('return type of snippet()', () {
+      final result = engine
+          .analyze("SELECT *, snippet(foo, 0, '<b>', '</b>', '...', 20) AS b "
+              "FROM foo WHERE foo MATCH ''");
+
+      final select = result.root as SelectStatement;
+      final column = select.resolvedColumns.singleWhere((c) => c.name == 'b');
+      expect(result.typeOf(column),
+          const ResolveResult(ResolvedType(type: BasicType.text)));
+    });
+  });
+
+  group('type inference for function arguments', () {
+    SqlEngine engine;
+    setUp(() {
+      engine = SqlEngine(enableFts5: true);
+      // add an fts5 table for the following queries
+      final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING '
+          'fts5(bar, baz);');
+      engine.registerTable(SchemaFromCreateTable()
+          .read(fts5Result.root as TableInducingStatement));
+    });
+
+    void checkVarTypes(String sql, List<BasicType> expected) {
+      final result = engine.analyze(sql);
+      final foundVars = result.root.allDescendants.whereType<Variable>();
+
+      expect(
+        foundVars.map((Typeable t) => result.typeOf(t).type.type),
+        expected,
+      );
+    }
+
+    test('for highlight()', () {
+      checkVarTypes(
+        'SELECT highlight(fts, ?, ?, ?) FROM fts;',
+        [
+          BasicType.int, // column index
+          BasicType.text, // text before phrase match
+          BasicType.text, // text after phrase match
+        ],
+      );
+    });
+
+    test('for snippet()', () {
+      checkVarTypes(
+        'SELECT snippet(fts, ?, ?, ?, ?, ?) FROM fts;',
+        [
+          BasicType.int, // column index
+          BasicType.text, // text before match
+          BasicType.text, // text after match
+          BasicType.text, // text to add match isn't at start
+          BasicType.int, // maximum number of tokens
+        ],
+      );
+    });
+  });
+
+  group('error reporting', () {
+    SqlEngine engine;
+    setUp(() {
+      engine = SqlEngine(enableFts5: true);
+      // add an fts5 table for the following queries
+      final fts5Result = engine.analyze('CREATE VIRTUAL TABLE foo USING '
+          'fts5(bar, baz);');
+      engine.registerTable(SchemaFromCreateTable()
+          .read(fts5Result.root as TableInducingStatement));
+
+      final normalResult = engine.analyze('CREATE TABLE other (bar TEXT);');
+      engine.registerTable(SchemaFromCreateTable()
+          .read(normalResult.root as TableInducingStatement));
+    });
+
+    Matcher hasMessage(Object msgMatcher) {
+      return const TypeMatcher<AnalysisError>()
+          .having((e) => e.message, 'message', msgMatcher);
+    }
+
+    test('when using star function parameters', () {
+      final result = engine.analyze('SELECT bm25(*) FROM foo;');
+      expect(result.errors, [hasMessage(contains('star parameter'))]);
+    });
+
+    test('when using a non-fts5 table as parameter', () {
+      final result = engine.analyze('SELECT bm25(bar) FROM other');
+      expect(result.errors, [hasMessage(contains('fts5 table name'))]);
+    });
+
+    test('when using the wrong number or arguments', () {
+      final result = engine.analyze('SELECT highlight(foo, 3) FROM foo');
+      expect(
+        result.errors,
+        [
+          hasMessage(stringContainsInOrder(['highlight', '4', '2']))
+        ],
+      );
+    });
   });
 }