Release v1.3.2 (#57)

* [FEATURE]: Add Support for Raw Strings (#51)

* Adds raw string literal parsing
Implements a parser for raw string literals, allowing strings to span multiple lines and contain quotes without escaping.
This simplifies string handling and improves code readability.

---------

Co-authored-by: Matt Edwards <matthew.edwards@wagglebee.net>

* [FEATURE]: Enhance TypeResolver for Member (#55)

* Introduces ITypeResolver interface

Refactors the TypeResolver class into an interface and an implementation.
This allows for easier mocking and customization of type resolution logic.
Also, this prepares the codebase for future extensions and testing.

---------

Co-authored-by: Matt Edwards <matthew.edwards@wagglebee.net>

* Refactors member access and indexer resolution

Moves member access and indexer resolution logic from the parser to the type resolver.

This change centralizes these operations within the type resolver, promoting code reuse and improving maintainability.
It also removes duplicate code from the parser.

* Updated code formatting to match rules in .editorconfig

* Refactors type resolution for extensibility

Separates type resolution and expression rewriting into distinct interfaces.

This change improves the extensibility of the type resolution process by
introducing the `ITypeRewriter` interface. The original `ITypeResolver` is
now focused solely on resolving types and members, while the new interface
handles the rewriting of expressions, such as indexers and member accesses.
This allows for more flexible customization of how expressions are transformed
during the parsing process.

* Improves error handling and termination parsing

Adds specific error messages for invalid termination, enhancing debugging.

Prevents type parsing from misinterpreting labels as part of the type definition.

Includes base message in SyntaxException to give full exception context.

---------

Co-authored-by: annette.findley <annette.varndell@wagglebee.net>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: github-actions <github-actions@github.com>

Author: 4 people

samples/extensions.dib

@@ -1,6 +1,6 @@
 #!meta
 
-{"kernelInfo":{"defaultKernelName":"csharp","items":[{"aliases":[],"languageName":"csharp","name":"csharp"},{"aliases":[],"name":"razor"},{"aliases":[],"name":"xs"},{"aliases":[],"name":"xs-show"}]}}
+{"kernelInfo":{"defaultKernelName":"csharp","items":[{"name":"csharp","languageName":"csharp"},{"name":"razor"},{"name":"xs"},{"name":"xs-show"},{"name":"fsharp","languageName":"F#","aliases":["f#","fs"]},{"name":"html","languageName":"HTML"},{"name":"http","languageName":"HTTP"},{"name":"javascript","languageName":"JavaScript","aliases":["js"]},{"name":"mermaid","languageName":"Mermaid"},{"name":"pwsh","languageName":"PowerShell","aliases":["powershell"]},{"name":"value"}]}}
 
 #!pwsh
 

src/Hyperbee.XS/Core/Parsers/RawStringParser.cs

@@ -0,0 +1,103 @@
+using Parlot;
+using Parlot.Fluent;
+
+namespace Hyperbee.XS.Core.Parsers;
+
+public class RawStringParser : Parser<TextSpan>
+{
+    private enum ParserState
+    {
+        Initial,
+        BeginContent,
+        Content,
+        EndContent
+    }
+
+    public override bool Parse( ParseContext context, ref ParseResult<TextSpan> result )
+    {
+        context.EnterParser( this );
+
+        var scanner = context.Scanner;
+        var cursor = scanner.Cursor;
+        var start = cursor.Position;
+        TextPosition begin = default;
+
+        scanner.SkipWhiteSpaceOrNewLine();
+
+        var state = ParserState.Initial;
+        var quoteCount = 0;
+        var requiredQuoteCount = 0;
+
+        while ( true )
+        {
+            var current = cursor.Current;
+
+            switch ( state )
+            {
+                case ParserState.Initial:
+                    if ( current == '"' )
+                    {
+                        quoteCount++;
+                    }
+                    else if ( quoteCount >= 3 )
+                    {
+                        state = ParserState.BeginContent;
+                        requiredQuoteCount = quoteCount;
+                        begin = scanner.Cursor.Position;
+                    }
+                    else
+                    {
+                        scanner.Cursor.ResetPosition( start );
+                        context.ExitParser( this );
+                        return false;
+                    }
+                    break;
+
+                case ParserState.BeginContent:
+                    state = ParserState.Content;
+                    quoteCount = 0;
+                    break;
+
+                case ParserState.Content:
+                    if ( current == '"' )
+                    {
+                        quoteCount++;
+                        if ( quoteCount == requiredQuoteCount )
+                        {
+                            state = ParserState.EndContent;
+                        }
+                    }
+                    else
+                    {
+                        quoteCount = 0;
+                    }
+                    break;
+
+                case ParserState.EndContent:
+                    var end = scanner.Cursor.Position.Offset;
+
+                    var decoded = Character.DecodeString(
+                        new TextSpan( scanner.Buffer, begin.Offset, end - begin.Offset - requiredQuoteCount )
+                    );
+
+                    result.Set( start.Offset, end, decoded );
+                    context.ExitParser( this );
+                    cursor.Advance();
+
+                    return true;
+
+                default:
+                    throw new ParseException( $"Invalid state for {nameof( RawStringParser )} found.", start );
+            }
+
+            cursor.Advance();
+
+            if ( !cursor.Eof )
+                continue;
+
+            scanner.Cursor.ResetPosition( start );
+            context.ExitParser( this );
+            return false;
+        }
+    }
+}

src/Hyperbee.XS/Core/Parsers/TerminationParser.cs

@@ -19,8 +19,8 @@ public static Parser<T> WithTermination<T>( this Parser<T> parser )
     {
         return parser.AndSkipIf(
             ( ctx, _ ) => ((XsContext) ctx).RequireTermination,
-            OneOrMany( Terms.Char( ';' ) ),
-            ZeroOrMany( Terms.Char( ';' ) ).RequireTermination( true )
+            OneOrMany( Terms.Char( ';' ) ).ElseError( XsParser.InvalidTerminationMessage ),
+            ZeroOrMany( Terms.Char( ';' ) ).RequireTermination( true ).ElseError( XsParser.InvalidTerminationMessage )
         ).Named( "Termination" );
     }
 }

src/Hyperbee.XS/Core/Parsers/TypeRuntimeParser.cs

@@ -51,6 +51,14 @@ public override bool Parse( ParseContext context, ref ParseResult<Type> result )
             scanner.SkipWhiteSpaceOrNewLine();
         }
 
+        if ( scanner.Cursor.Current == ':' )
+        {
+            // Invalid for types to end with a colon (Identifier is being used as a label)
+            cursor.ResetPosition( start );
+            context.ExitParser( this );
+            return false;
+        }
+
         // get any generic argument types
 
         var genericArgs = new List<Type>();

src/Hyperbee.XS/Core/TypeResolver.cs

@@ -6,7 +6,19 @@
 
 namespace Hyperbee.XS.Core;
 
-public sealed class TypeResolver
+public interface ITypeResolver
+{
+    Type ResolveType( string typeName );
+    MethodInfo ResolveMethod( Type type, string methodName, IReadOnlyList<Type> typeArgs, IReadOnlyList<Expression> args );
+    MemberInfo ResolveMember( Type type, string memberName );
+}
+public interface ITypeRewriter
+{
+    Expression RewriteIndexerExpression( Expression targetExpression, IReadOnlyList<Expression> indexes );
+    Expression RewriteMemberExpression( Expression targetExpression, string name, IReadOnlyList<Type> typeArgs, IReadOnlyList<Expression> args );
+}
+
+public class TypeResolver : ITypeResolver, ITypeRewriter
 {
     public ReferenceManager ReferenceManager { get; }
 
@@ -53,7 +65,7 @@ public TypeResolver( ReferenceManager referenceManager )
         ReferenceManager = referenceManager;
     }
 
-    public Type ResolveType( string typeName )
+    public virtual Type ResolveType( string typeName )
     {
         return _typeCache.GetOrAdd( typeName, _ =>
         {
@@ -93,7 +105,7 @@ static Type GetTypeFromKeyword( string typeName )
         }
     }
 
-    public MethodInfo ResolveMethod( Type type, string methodName, IReadOnlyList<Type> typeArgs, IReadOnlyList<Expression> args )
+    public virtual MethodInfo ResolveMethod( Type type, string methodName, IReadOnlyList<Type> typeArgs, IReadOnlyList<Expression> args )
     {
         var candidateMethods = GetCandidateMethods( methodName, type );
         var callerTypes = GetCallerTypes( type, args );
@@ -153,6 +165,106 @@ public MethodInfo ResolveMethod( Type type, string methodName, IReadOnlyList<Typ
         return bestMatch;
     }
 
+    public virtual MemberInfo ResolveMember( Type type, string memberName )
+    {
+        const BindingFlags BindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;
+        return type.GetMember( memberName, BindingAttr ).FirstOrDefault();
+    }
+
+    public virtual Expression RewriteIndexerExpression( Expression targetExpression, IReadOnlyList<Expression> indexes )
+    {
+        var indexers = targetExpression.Type.GetProperties()
+            .Where( p => p.GetIndexParameters().Length == indexes.Count )
+            .ToArray();
+
+        if ( indexers.Length == 0 )
+            return Expression.ArrayAccess( targetExpression, indexes );
+
+        // Find the best match based on parameter types
+        var indexer = indexers.FirstOrDefault( p =>
+            p.GetIndexParameters()
+                .Select( param => param.ParameterType )
+                .SequenceEqual( indexes.Select( i => i.Type ) ) );
+
+        if ( indexer == null )
+        {
+            throw new InvalidOperationException(
+                $"No matching indexer found on type '{targetExpression.Type}' with parameter types: " +
+                $"{string.Join( ", ", indexes.Select( i => i.Type.Name ) )}." );
+        }
+
+        return Expression.Property( targetExpression, indexer, indexes.ToArray() );
+    }
+
+    public virtual Expression RewriteMemberExpression( Expression targetExpression, string name, IReadOnlyList<Type> typeArgs, IReadOnlyList<Expression> args )
+    {
+        var type = TypeOf( targetExpression );
+
+        // method
+
+        if ( args != null )
+        {
+            var method = ResolveMethod( type, name, typeArgs, args );
+
+            if ( method == null )
+                throw new InvalidOperationException( $"Method '{name}' not found on type '{type}'." );
+
+            var arguments = GetArgumentsWithDefaults( method, targetExpression, args );
+
+            return method.IsStatic
+                ? Expression.Call( method, arguments )
+                : Expression.Call( targetExpression, method, arguments );
+        }
+
+        // property or field
+
+        var member = ResolveMember( type, name );
+
+        if ( member == null )
+            throw new InvalidOperationException( $"Member '{name}' not found on type '{type}'." );
+
+        return member switch
+        {
+            PropertyInfo property => Expression.Property( targetExpression, property ),
+            FieldInfo field => Expression.Field( targetExpression, field ),
+            _ => throw new InvalidOperationException( $"Member '{name}' is not a property or field." )
+        };
+
+        static IReadOnlyList<Expression> GetArgumentsWithDefaults( MethodInfo method, Expression targetExpression, IReadOnlyList<Expression> providedArgs )
+        {
+            var parameters = method.GetParameters();
+            var isExtension = method.IsDefined( typeof( ExtensionAttribute ), false );
+
+            var providedOffset = isExtension ? 1 : 0;
+            var providedCount = providedArgs.Count;
+            var totalParameters = parameters.Length;
+
+            if ( providedCount == totalParameters )
+                return providedArgs;
+
+            var methodArgs = new Expression[totalParameters];
+
+            // add provided arguments
+            if ( isExtension )
+                methodArgs[0] = targetExpression;
+
+            for ( var i = 0; i < providedCount; i++ )
+            {
+                methodArgs[i + providedOffset] = providedArgs[i];
+            }
+
+            // add missing optional parameters
+            for ( var i = providedCount + providedOffset; i < totalParameters; i++ )
+            {
+                methodArgs[i] = parameters[i].HasDefaultValue
+                    ? Expression.Constant( parameters[i].DefaultValue, parameters[i].ParameterType )
+                    : throw new ArgumentException( $"Missing required parameter: {parameters[i].Name}" );
+            }
+
+            return methodArgs;
+        }
+    }
+
     public void RegisterExtensionMethods( IEnumerable<Assembly> assemblies )
     {
         Parallel.ForEach( assemblies, assembly =>
@@ -386,5 +498,18 @@ private static int CompareMethods( MethodInfo m1, MethodInfo m2 )
 
         return p1.Length.CompareTo( p2.Length );
     }
+
+    [MethodImpl( MethodImplOptions.AggressiveInlining )]
+    private static Type TypeOf( Expression expression )
+    {
+        ArgumentNullException.ThrowIfNull( expression, nameof( expression ) );
+
+        return expression switch
+        {
+            ConstantExpression ce => ce.Value as Type ?? ce.Type,
+            _ => expression.Type
+        };
+    }
+
 }
 

src/Hyperbee.XS/SyntaxException.cs

@@ -30,7 +30,7 @@ public override string Message
             var sourceLine = BufferHelper.GetLine( Buffer, Offset, out var caret );
             var caretLine = new string( ' ', caret ) + "^";
 
-            return $"({Line} {Column})\n{sourceLine}\n{caretLine}";
+            return $"{base.Message}\n({Line} {Column})\n{sourceLine}\n{caretLine}";
         }
     }
 }

src/Hyperbee.XS/XsParser.Identifiers.cs

@@ -8,6 +8,7 @@ namespace Hyperbee.XS;
 public partial class XsParser
 {
     public const string InvalidSyntaxMessage = "Invalid syntax.";
+    public const string InvalidTerminationMessage = "Invalid termination, missing ';'.";
     public const string InvalidTypeMessage = "Invalid type.";
     public const string InvalidExpressionMessage = "Invalid expression.";
     public const string InvalidStatementMessage = "Invalid statement.";
@@ -21,7 +22,7 @@ public partial class XsParser
     internal static Parser<char> CloseBracket = Terms.Char( ']' ).ElseError( InvalidSyntaxMessage );
     internal static Parser<char> Assignment = Terms.Char( '=' ).ElseError( InvalidSyntaxMessage );
     internal static Parser<char> Delimiter = Terms.Char( ',' ).ElseError( InvalidSyntaxMessage );
-    internal static Parser<char> Terminator = Terms.Char( ';' ).ElseError( InvalidSyntaxMessage );
+    internal static Parser<char> Terminator = Terms.Char( ';' ).ElseError( InvalidTerminationMessage );
     internal static Parser<char> Colon = Terms.Char( ':' ).ElseError( InvalidSyntaxMessage );
 }
 

src/Hyperbee.XS/XsParser.Literals.cs

@@ -35,6 +35,9 @@ private static Parser<Expression> LiteralParser( XsConfig config, Deferred<Expre
         var stringLiteral = Terms.String( StringLiteralQuotes.Double )
             .Then<Expression>( static value => Constant( value.ToString() ) );
 
+        var rawStringLiteral = new RawStringParser().
+            Then<Expression>( static value => Constant( value.ToString() ) );
+
         var nullLiteral = Terms.Text( "null" )
             .Then<Expression>( static _ => Constant( null ) );
 
@@ -43,6 +46,7 @@ private static Parser<Expression> LiteralParser( XsConfig config, Deferred<Expre
             doubleLiteral,
             floatLiteral,
             integerLiteral,
+            rawStringLiteral,
             characterLiteral,
             stringLiteral,
             booleanLiteral,