From fce9e77926027d93ac8fd09cc37f14700cfbc5c8 Mon Sep 17 00:00:00 2001 From: nosami Date: Thu, 20 Oct 2022 18:12:06 +0100 Subject: More tests passing --- .../NRefactoryExpressionEvaluatorVisitor.cs | 168 +++++++++++++++++---- 1 file changed, 141 insertions(+), 27 deletions(-) diff --git a/Mono.Debugging/Mono.Debugging.Evaluation/NRefactoryExpressionEvaluatorVisitor.cs b/Mono.Debugging/Mono.Debugging.Evaluation/NRefactoryExpressionEvaluatorVisitor.cs index 4f4715a..66e0c71 100644 --- a/Mono.Debugging/Mono.Debugging.Evaluation/NRefactoryExpressionEvaluatorVisitor.cs +++ b/Mono.Debugging/Mono.Debugging.Evaluation/NRefactoryExpressionEvaluatorVisitor.cs @@ -552,12 +552,20 @@ namespace Mono.Debugging.Evaluation var type = Visit(node.Type.ElementType); if (type == null) throw ParseError ("Invalid type in array creation."); - var lengths = new int [node.Initializer.Expressions.Count]; - for (int i = 0; i < lengths.Length; i++) { - lengths [i] = (int)Convert.ChangeType (Visit(node.Initializer.Expressions[i]).ObjectValue, typeof (int)); + //var lengths = new int [node.Initializer.Expressions.Count]; + //for (int i = 0; i < lengths.Length; i++) { + // lengths [i] = (int)Convert.ChangeType (Visit(node.Initializer.Expressions[i]).ObjectValue, typeof (int)); + + var lengths = Array.Empty(); + if (node.Type is ArrayTypeSyntax ats) { + lengths = new int[ats.RankSpecifiers[0].Sizes.Count]; + for (int i = 0; i < lengths.Length; i++) { + var arsi = ats.RankSpecifiers[0].Sizes[i]; + lengths [i] = (int)Convert.ChangeType (Visit(arsi).ObjectValue, typeof (int)); + } } var array = ctx.Adapter.CreateArray (ctx, type.Type, lengths); - if (node.Initializer.Expressions.Count > 0) { + if (node.Initializer?.Expressions.Count > 0) { var arrayAdaptor = ctx.Adapter.CreateArrayAdaptor (ctx, array); int index = 0; foreach (var el in LinearElements(node.Initializer.Expressions)) { @@ -566,14 +574,40 @@ namespace Mono.Debugging.Evaluation } return LiteralValueReference.CreateTargetObjectLiteral (ctx, expression, array); } - + //public ValueReference VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression) + //{ + // var type = arrayCreateExpression.Type.AcceptVisitor(this) as TypeValueReference; + // if (type == null) + // throw ParseError("Invalid type in array creation."); + // var lengths = new int[arrayCreateExpression.Arguments.Count]; + // for (int i = 0; i < lengths.Length; i++) + // { + // lengths[i] = (int)Convert.ChangeType(arrayCreateExpression.Arguments.ElementAt(i).AcceptVisitor(this).ObjectValue, typeof(int)); + // } + // var array = ctx.Adapter.CreateArray(ctx, type.Type, lengths); + // if (arrayCreateExpression.Initializer.Elements.Any()) + // { + // var arrayAdaptor = ctx.Adapter.CreateArrayAdaptor(ctx, array); + // int index = 0; + // foreach (var el in LinearElements(arrayCreateExpression.Initializer.Elements)) + // { + // arrayAdaptor.SetElement(new int[] { index++ }, el.AcceptVisitor(this).Value); + // } + // } + // return LiteralValueReference.CreateTargetObjectLiteral(ctx, expression, array); + //} IEnumerable LinearElements (SeparatedSyntaxList elements) { foreach (var el in elements) { - if (el is ArrayCreationExpressionSyntax arrCre) + if (el is ArrayCreationExpressionSyntax arrCre) { foreach (var el2 in LinearElements (arrCre.Initializer.Expressions)) { yield return el2; - } else + } + } else if (el is InitializerExpressionSyntax ies) { + foreach (var el2 in LinearElements (ies.Expressions)) { + yield return el2; + } + } else yield return el; } } @@ -1004,25 +1038,47 @@ namespace Mono.Debugging.Evaluation throw NotSupported (); } - public override ValueReference VisitMemberAccessExpression (MemberAccessExpressionSyntax node) { + DebuggerLoggingService.LogMessage("{0} {1}", node.ToString(), node.Name.GetType()); if (node.Name is GenericNameSyntax gns) return ResolveTypeValueReference (ctx, node); + if (node.Name is IdentifierNameSyntax ins) + { + //var type = this.Visit(ins); + var name = ResolveTypeName(node); + var type = ctx.Adapter.GetType(ctx, name); + + if (type != null) + return new TypeValueReference(ctx, type); + + if (node.Expression is MemberAccessExpressionSyntax) + return new NamespaceValueReference(ctx, name); + } var target = Visit (node.Expression); - var member = target.GetChild (node.Name.Identifier.ValueText, ctx.Options); - if (member == null) { - if (!(target is TypeValueReference)) { - if (ctx.Adapter.IsNull (ctx, target.Value)) - throw new EvaluatorException ("{0} is null", target.Name); - } + //if (target is TypeValueReference) { + + // var name = ResolveTypeName(node); + // var type = ctx.Adapter.GetType(ctx, name); - throw ParseError ("Unknown member: {0}", node.Name.Identifier.ValueText); + // if (type != null) + // return new TypeValueReference(ctx, type); + // // Assume it is a namespace + // return new NamespaceValueReference(ctx, name); + //} + var member = target.GetChild(node.Name.Identifier.ValueText, ctx.Options); + + if (member != null) + return member; + + if (!(target is TypeValueReference)) { + if (ctx.Adapter.IsNull(ctx, target.Value)) + throw new EvaluatorException("{0} is null", target.Name); } + throw new EvaluatorException("{0} is null", target.Name); - return member; } public override ValueReference VisitLiteralExpression (LiteralExpressionSyntax node) @@ -1069,8 +1125,8 @@ namespace Mono.Debugging.Evaluation public override ValueReference VisitTypeOfExpression (TypeOfExpressionSyntax node) { var name = ResolveTypeName (node.Type); - var type = node.Type.Resolve (ctx); + var type = ctx.Adapter.GetType(ctx, name); if (type == null) throw ParseError ("Could not load type: {0}", name); @@ -1216,20 +1272,78 @@ namespace Mono.Debugging.Evaluation public override ValueReference VisitNullableType (NullableTypeSyntax node) { - //if(node.) - var value = this.Visit(node.ElementType); - - var type1 = ctx.Adapter.GetType(ctx, NRefactoryExtensions.Resolve(node.ElementType.ToString())); - //ctx.Adapter. - ValueReference nullable = ctx.Adapter.NullableGetValue(ctx, type1, value); - return nullable; - return this.Visit(node.ElementType); + if (node.ElementType is PredefinedTypeSyntax predefinedTypeSyntax) + { + var type = ctx.Adapter.GetType(ctx, GetNullableKind(predefinedTypeSyntax)); + return new TypeValueReference(ctx, type); + } + return null; //TODO: + + ////if(node.) + //var value = this.Visit(node.ElementType); + //string nullableKind; + //var type1 = ctx.Adapter.GetType(ctx, NRefactoryExtensions.Resolve(node.ElementType.ToString())); + ////ctx.Adapter. + //ValueReference nullable = ctx.Adapter.NullableGetValue(ctx, type1, value); + //return nullable; + //return this.Visit(node.ElementType); } - public override ValueReference VisitQualifiedName (QualifiedNameSyntax node) + private string GetNullableKind(PredefinedTypeSyntax type) { - return Visit(node.Right); + switch (type.Keyword.Kind()) { + case SyntaxKind.BoolKeyword: return "System.Nullable"; + case SyntaxKind.SByteKeyword: return "System.Nullable"; + case SyntaxKind.ByteKeyword: return "System.Nullable"; + case SyntaxKind.CharKeyword: return "System.Nullable"; + case SyntaxKind.ShortKeyword: return "System.Nullable"; + case SyntaxKind.UShortKeyword: return "System.Nullable"; + case SyntaxKind.IntKeyword: return "System.Nullable"; + case SyntaxKind.UIntKeyword: return "System.Nullable"; + case SyntaxKind.LongKeyword: return "System.Nullable"; + case SyntaxKind.ULongKeyword: return "System.Nullable"; + case SyntaxKind.FloatKeyword: return "System.Nullable"; + case SyntaxKind.DoubleKeyword: return "System.Nullable"; + case SyntaxKind.DecimalKeyword: return "System.Nullable"; + default: return null; + } } + + public override ValueReference VisitGenericName (GenericNameSyntax node) + { + var type = node.Resolve(ctx); + return new TypeValueReference(ctx, type); + + //node. + //object[] typeArgs; + // if (node.Arity > 0) { + // var args = new List (); + + // foreach (var arg in node.TypeArgumentList.Arguments) { + // var type = Visit(arg); + // args.Add (type.Type); + // } + + // typeArgs = args.ToArray (); + //} else { + // typeArgs = null; + // } + ////var type = Visit(node.Type) as TypeValueReference; + ////var args = new List(); + + ////foreach (var arg in node.ArgumentList.Arguments) + ////{ + //// var val = Visit(arg); + //// args.Add(val != null ? val.Value : null); + ////} + //var val = ctx.Adapter.CreateValue( ) + //return LiteralValueReference.CreateTargetObjectLiteral(ctx, expression, ctx.Adapter.CreateValue(ctx, type.Type, args.ToArray())); + + } + //public override ValueReference VisitQualifiedName (QualifiedNameSyntax node) + //{ + // return Visit(node.Right); + //} public override ValueReference DefaultVisit (SyntaxNode node) { if (node is LiteralExpressionSyntax syntax) -- cgit v1.2.3