Browse Source

The Boo AddIn now supports code completion for generics. The C# -> Boo converter now supports converting generic type references.

NRefactory now uses CastExpression for all cast types ("DirectCast", "CType", "TryCast"). TypeOfIsExpression now used by C# instead of BinaryOperatorType.TypeTest.
Updated to new Boo version that supports parsing and writing generic type references.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@763 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61
shortcuts
Daniel Grunwald 20 years ago
parent
commit
a6852502a4
  1. 2
      AddIns/ICSharpCode.SharpDevelop.addin
  2. 3
      src/AddIns/BackendBindings/Boo/Boo.Microsoft.Build.Tasks/Boo.Microsoft.Build.Tasks.booproj
  3. 218
      src/AddIns/BackendBindings/Boo/Boo.Microsoft.Build.Tasks/Boo.Microsoft.Build.targets
  4. 2
      src/AddIns/BackendBindings/Boo/BooBinding/Project/PostBuildEvent.proj
  5. 2
      src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/BooResolver.cs
  6. 29
      src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ConvertVisitor.cs
  7. 50
      src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ResolveVisitor.cs
  8. 17
      src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitor.cs
  9. 63
      src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitorExpressions.cs
  10. 48
      src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Test/ExpressionTests.cs
  11. 7
      src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Test/MemberTests.cs
  12. 10
      src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlView.cs
  13. 2
      src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Service/DynamicTreeDebuggerRow.cs
  14. 6
      src/Libraries/ICSharpCode.TextEditor/Project/Resources/Boo.xshd
  15. 30
      src/Libraries/NRefactory/Project/Src/Output/CSharp/CSharpOutputVisitor.cs
  16. 5
      src/Libraries/NRefactory/Project/Src/Output/CodeDOM/CodeDOMOutputVisitor.cs
  17. 41
      src/Libraries/NRefactory/Project/Src/Output/VBNet/VBNetOutputVisitor.cs
  18. 5
      src/Libraries/NRefactory/Project/Src/Parser/AST/General/Expressions/BinaryOperatorExpression.cs
  19. 37
      src/Libraries/NRefactory/Project/Src/Parser/AST/General/Expressions/CastExpression.cs
  20. 16
      src/Libraries/NRefactory/Project/Src/Parser/AST/VBNet/Expressions/TypeOfIsExpression.cs
  21. 176
      src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs
  22. 26
      src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG
  23. 1151
      src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs
  24. 12
      src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG
  25. 12
      src/Libraries/NRefactory/Test/Output/CSharp/CSharpOutputTest.cs
  26. 24
      src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs
  27. 20
      src/Libraries/NRefactory/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs
  28. 75
      src/Libraries/NRefactory/Test/Parser/Expressions/CastExpressionTests.cs
  29. 4
      src/Libraries/NRefactory/Test/Parser/Expressions/ConditionalExpressionTests.cs
  30. 28
      src/Libraries/NRefactory/Test/Parser/Expressions/TypeOfIsExpressionTests.cs
  31. 6
      src/Main/Base/Project/Src/Dom/ClassFinder.cs
  32. 18
      src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs

2
AddIns/ICSharpCode.SharpDevelop.addin

@ -1434,7 +1434,7 @@ @@ -1434,7 +1434,7 @@
<Path name = "/SharpDevelop/Pads/ProjectBrowser/ContextMenu/ProjectNode">
<MenuItem id = "ExportToHtml"
insertafter = "AddSeparator"
insertbefore = "SetAsStartupProjectSeparator"
insertbefore = "Separator2"
label = "${res:ProjectComponent.ContextMenu.HtmlExport}"
class = "ICSharpCode.SharpDevelop.DefaultEditor.Commands.ExportProjectToHtml"/>
</Path>

3
src/AddIns/BackendBindings/Boo/Boo.Microsoft.Build.Tasks/Boo.Microsoft.Build.Tasks.booproj

@ -33,8 +33,9 @@ @@ -33,8 +33,9 @@
</ItemGroup>
<ItemGroup>
<Content Include="Project.booproj" />
<Content Include="Boo.Microsoft.Build.targets">
<Content Include="..\RequiredLibraries\Boo.Microsoft.Build.targets">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
<Link>Boo.Microsoft.Build.targets</Link>
</Content>
</ItemGroup>
<Import Project="$(BooBinPath)\Boo.Microsoft.Build.targets" />

218
src/AddIns/BackendBindings/Boo/Boo.Microsoft.Build.Tasks/Boo.Microsoft.Build.targets

@ -1,218 +0,0 @@ @@ -1,218 +0,0 @@
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<UsingTask
TaskName="Microsoft.Build.Tasks.CreateBooManifestResourceName"
AssemblyFile="Boo.Microsoft.Build.Tasks.dll" />
<UsingTask
TaskName="Boo.Microsoft.Build.Tasks.Booc"
AssemblyFile="Boo.Microsoft.Build.Tasks.dll"/>
<PropertyGroup>
<MSBuildAllProjects Condition="'$(BoocToolPath)' != ''">
$(MSBuildAllProjects);$(BoocToolPath)\Boo.Microsoft.Build.targets
</MSBuildAllProjects>
<MSBuildAllProjects Condition="'$(BoocToolPath)' == ''">
$(MSBuildAllProjects);$(MSBuildBinPath)\Boo.Microsoft.Build.targets
</MSBuildAllProjects>
<DefaultLanguageSourceExtension>.boo</DefaultLanguageSourceExtension>
<Language>Boo</Language>
</PropertyGroup>
<!--
The CreateManifestResourceNames target create the manifest resource names
from the .RESX files.
[IN]
@(ResxWithNoCulture) - The names the non-culture .RESX files.
@(ResxWithCulture) - The names the culture .RESX files.
@(NonResxWithNoCulture) - The names of the non-culture non-RESX
files (like bitmaps, etc).
@(NonResxWithCulture) - The names of the culture non-RESX
files (like bitmaps, etc).
[OUT]
@(ManifestResourceWithNoCultureName) - The corresponding manifest
resource name (.RESOURCE)
@(ManifestResourceWithCultureName) - The corresponding manifest
resource name (.RESOURCE)
@(ManifestNonResxWithNoCulture) - The corresponding manifest
resource name.
@(ManifestNonResxWithCulture) - The corresponding manifest
resource name.
For Boo applications the transformation is like:
Resources1.resx => RootNamespace.Resources1 => Build into main assembly
SubFolder\Resources1.resx =>
RootNamespace.SubFolder.Resources1 =>
Build into main assembly
Resources1.fr.resx =>
RootNamespace.Resources1.fr =>
Build into satellite assembly
Resources1.notaculture.resx =>
RootNamespace.Resources1.notaculture =>
Build into main assembly
For other project systems, this transformation may be different.
-->
<PropertyGroup>
<CreateManifestResourceNamesDependsOn>
</CreateManifestResourceNamesDependsOn>
</PropertyGroup>
<Target
Name="CreateManifestResourceNames"
Condition="'
@(ResxWithNoCulture)
@(ResxWithCulture)
@(NonResxWithNoCulture)
@(NonResxWithCulture)'!=''"
DependsOnTargets="$(CreateManifestResourceNamesDependsOn)"
>
<!-- Create the target resource names for non-culture resx files -->
<CreateBooManifestResourceName
Condition="'@(ResxWithNoCulture)'!=''"
ResourceFiles="@(ResxWithNoCulture)"
RootNamespace="$(RootNamespace)">
<Output
TaskParameter="ManifestResourceNames"
ItemName="ManifestResourceWithNoCultureName"/>
</CreateBooManifestResourceName>
<!-- Create the target resource names for culture resx files. -->
<CreateBooManifestResourceName
Condition="'@(ResxWithCulture)'!=''"
ResourceFiles="@(ResxWithCulture)"
RootNamespace="$(RootNamespace)">
<Output
TaskParameter="ManifestResourceNames"
ItemName="ManifestResourceWithCultureName"/>
</CreateBooManifestResourceName>
<!-- Create the target resource names for non-culture non-resx files. -->
<CreateBooManifestResourceName
Condition="'@(NonResxWithNoCulture)'!=''"
ResourceFiles="@(NonResxWithNoCulture)"
RootNamespace="$(RootNamespace)">
<Output
TaskParameter="ManifestResourceNames"
ItemName="ManifestNonResxWithNoCulture"/>
</CreateBooManifestResourceName>
<!-- Create the target resource names for culture non-resx files. -->
<CreateBooManifestResourceName
Condition="'@(NonResxWithCulture)'!=''"
ResourceFiles="@(NonResxWithCulture)"
RootNamespace="$(RootNamespace)">
<Output
TaskParameter="ManifestResourceNames"
ItemName="ManifestNonResxWithCulture"/>
</CreateBooManifestResourceName>
</Target>
<PropertyGroup>
<!--
"None" is not technically a valid DebugType, so we can't pass it
in as such to the compiler. So here, we modify the properties so
they make sense.
-->
<DebugSymbols Condition="'$(DebugType)' == 'none'">false</DebugSymbols>
<DebugType Condition="'$(DebugType)' == 'none'"></DebugType>
<!-- Provide a facility to override UseHostCompilerIfAvailable-->
<UseHostCompilerIfAvailable
Condition="'$(UseHostCompilerIfAvailable)' == ''">
true
</UseHostCompilerIfAvailable>
</PropertyGroup>
<ItemGroup>
<DocFileItem
Include="$(DocumentationFile)"
Condition="'$(DocumentationFile)'!=''">
<InProject>false</InProject>
</DocFileItem>
</ItemGroup>
<PropertyGroup>
<CoreCompileDependsOn>
_ComputeNonExistentFileProperty
</CoreCompileDependsOn>
</PropertyGroup>
<PropertyGroup Condition=" '$(BoocToolPath)' != '' ">
<ReferencePath>$(ReferencePath);$(BoocToolPath)</ReferencePath>
</PropertyGroup>
<PropertyGroup Condition=" '$(BoocToolPath)' == '' ">
<ReferencePath>$(ReferencePath);$(BooBinPath)</ReferencePath>
</PropertyGroup>
<Target
Name="CoreCompile"
Inputs="$(MSBuildAllProjects);
@(Compile);
@(ManifestResourceWithNoCulture);
$(ApplicationIcon);
$(AssemblyOriginatorKeyFile);
@(ManifestNonResxWithNoCultureOnDisk);
@(ReferencePath);
@(CompiledLicenseFile)"
Outputs="@(DocFileItem);
@(IntermediateAssembly);
$(NonExistentFile)"
DependsOnTargets="$(CoreCompileDependsOn)"
>
<Booc
OutputAssembly="@(IntermediateAssembly)"
References="@(ReferencePath)"
Resources= "@(ManifestResourceWithNoCulture);
@(ManifestNonResxWithNoCultureOnDisk);
@(CompiledLicenseFile)"
ResponseFiles="$(CompilerResponseFile)"
Sources="@(Compile)"
TargetType="$(OutputType)"
ToolPath="$(BoocToolPath)"
Pipelines="@(Pipeline)"
Verbosity="$(BoocVerbosity)"
Culture="$(AssemblyCulture)"
SourceDirectory="$(SourceDirectory)"
/>
<Copy
Condition=" '$(BoocToolPath)' == '' "
SkipUnchangedFiles="true"
SourceFiles="$(BooBinPath)\Boo.Lang.dll"
DestinationFolder="$(OutputPath)"/>
<Copy
Condition=" '$(BoocToolPath)' != '' "
SkipUnchangedFiles="true"
SourceFiles="$(BoocToolPath)\Boo.Lang.dll"
DestinationFolder="$(OutputPath)"/>
</Target>
<Import Project="$(MSBuildBinPath)\Microsoft.Common.targets" />
</Project>

2
src/AddIns/BackendBindings/Boo/BooBinding/Project/PostBuildEvent.proj

@ -15,7 +15,7 @@ copy "%1\..\..\RequiredLibraries\Boo.Microsoft.Build.Tasks.dll" . @@ -15,7 +15,7 @@ copy "%1\..\..\RequiredLibraries\Boo.Microsoft.Build.Tasks.dll" .
</PropertyGroup>
<ItemGroup>
<MyCopyItem Include="$(MSBuildProjectDirectory)\..\..\RequiredLibraries\booc.*" />
<MyCopyItem Include="$(MSBuildProjectDirectory)\..\..\Boo.Microsoft.Build.Tasks\*.targets" />
<MyCopyItem Include="$(MSBuildProjectDirectory)\..\..\RequiredLibraries\*.targets" />
<MyCopyItem Include="$(MSBuildProjectDirectory)\..\..\RequiredLibraries\Boo.Microsoft.Build.Tasks.dll" />
</ItemGroup>
<Target Name="MyPostBuildTarget">

2
src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/BooResolver.cs

@ -233,7 +233,7 @@ namespace Grunwald.BooBinding.CodeCompletion @@ -233,7 +233,7 @@ namespace Grunwald.BooBinding.CodeCompletion
public IReturnType ConvertType(AST.TypeReference typeRef)
{
return ConvertVisitor.CreateReturnType(typeRef, callingClass, callingMember,
caretLine, caretColumn, pc, false);
caretLine, caretColumn, pc);
}
public IField FindLocalVariable(string name, bool acceptImplicit)

29
src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ConvertVisitor.cs

@ -191,15 +191,14 @@ namespace Grunwald.BooBinding.CodeCompletion @@ -191,15 +191,14 @@ namespace Grunwald.BooBinding.CodeCompletion
{
IClass c = OuterClass;
if (c == null) {
return CreateReturnType(reference, new DefaultClass(_cu, "___DummyClass"), method, 1, 1, _cu.ProjectContent, true);
return CreateReturnType(reference, new DefaultClass(_cu, "___DummyClass"), method, 1, 1, _cu.ProjectContent);
} else {
return CreateReturnType(reference, c, method, c.Region.BeginLine + 1, 1, _cu.ProjectContent, true);
return CreateReturnType(reference, c, method, c.Region.BeginLine + 1, 1, _cu.ProjectContent);
}
}
public static IReturnType CreateReturnType(AST.TypeReference reference, IClass callingClass,
IMember callingMember, int caretLine, int caretColumn,
IProjectContent projectContent,
bool useLazyReturnType)
IProjectContent projectContent)
{
if (reference == null) {
LoggingService.Warn("inferred return type!");
@ -208,14 +207,28 @@ namespace Grunwald.BooBinding.CodeCompletion @@ -208,14 +207,28 @@ namespace Grunwald.BooBinding.CodeCompletion
if (reference is AST.ArrayTypeReference) {
AST.ArrayTypeReference arr = (AST.ArrayTypeReference)reference;
return new ArrayReturnType(CreateReturnType(arr.ElementType, callingClass, callingMember,
caretLine, caretColumn, projectContent, useLazyReturnType),
caretLine, caretColumn, projectContent),
(arr.Rank != null) ? (int)arr.Rank.Value : 1);
} else if (reference is AST.SimpleTypeReference) {
string name = ((AST.SimpleTypeReference)reference).Name;
IReturnType rt;
int typeParameterCount = (reference is AST.GenericTypeReference) ? ((AST.GenericTypeReference)reference).GenericArguments.Count : 0;
if (BooAmbience.ReverseTypeConversionTable.ContainsKey(name))
return new GetClassReturnType(projectContent, BooAmbience.ReverseTypeConversionTable[name], 0);
return new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn,
name, 0);
rt = new GetClassReturnType(projectContent, BooAmbience.ReverseTypeConversionTable[name], typeParameterCount);
else
rt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn,
name, typeParameterCount);
if (typeParameterCount > 0) {
AST.TypeReferenceCollection arguments = ((AST.GenericTypeReference)reference).GenericArguments;
// GenericTypeReference derives from SimpleTypeReference
IReturnType[] typeArguments = new IReturnType[arguments.Count];
for (int i = 0; i < typeArguments.Length; i++) {
typeArguments[i] = CreateReturnType(arguments[i], callingClass, callingMember, caretLine, caretColumn,
projectContent);
}
rt = new ConstructedReturnType(rt, typeArguments);
}
return rt;
} else if (reference is AST.CallableTypeReference) {
return new AnonymousMethodReturnType();
} else {

50
src/AddIns/BackendBindings/Boo/BooBinding/Project/Src/CodeCompletion/ResolveVisitor.cs

@ -8,6 +8,7 @@ @@ -8,6 +8,7 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using ICSharpCode.Core;
using ICSharpCode.SharpDevelop.Dom;
using Boo.Lang.Compiler.Ast;
@ -206,6 +207,53 @@ namespace Grunwald.BooBinding.CodeCompletion @@ -206,6 +207,53 @@ namespace Grunwald.BooBinding.CodeCompletion
}
#endregion
#region OnGenericReferenceExpression
public override void OnGenericReferenceExpression(GenericReferenceExpression node)
{
MakeTypeResult(ConstructTypeFromGenericReferenceExpression(node));
}
public ConstructedReturnType ConstructTypeFromGenericReferenceExpression(GenericReferenceExpression node)
{
Stack<Expression> stack = new Stack<Expression>();
Expression expr = node;
while (expr != null) {
stack.Push(expr);
if (expr is MemberReferenceExpression) {
expr = ((MemberReferenceExpression)expr).Target;
} else if (expr is GenericReferenceExpression) {
expr = ((GenericReferenceExpression)expr).Target;
} else {
expr = null;
}
}
StringBuilder name = new StringBuilder();
List<IReturnType> typeArguments = new List<IReturnType>();
while (stack.Count > 0) {
expr = stack.Pop();
if (expr is MemberReferenceExpression) {
name.Append('.');
name.Append(((MemberReferenceExpression)expr).Name);
} else if (expr is GenericReferenceExpression) {
foreach (TypeReference tr in ((GenericReferenceExpression)expr).GenericArguments) {
typeArguments.Add(ConvertVisitor.CreateReturnType(tr, callingClass,
resolver.CallingMember,
resolver.CaretLine,
resolver.CaretColumn,
projectContent));
}
} else if (expr is ReferenceExpression) {
name.Append(((ReferenceExpression)expr).Name);
} else {
LoggingService.Warn("Unknown expression in GenericReferenceExpression: " + expr);
}
}
IReturnType rt = projectContent.SearchType(name.ToString(), typeArguments.Count, callingClass,
cu, resolver.CaretLine, resolver.CaretColumn);
return new ConstructedReturnType(rt, typeArguments);
}
#endregion
#region Resolve Member
public override void OnMemberReferenceExpression(MemberReferenceExpression node)
{
@ -550,7 +598,7 @@ namespace Grunwald.BooBinding.CodeCompletion @@ -550,7 +598,7 @@ namespace Grunwald.BooBinding.CodeCompletion
MakeResult(new ArrayReturnType(elementType, 1));
}
public override void OnAsExpression(AsExpression node)
public override void OnTryCastExpression(TryCastExpression node)
{
MakeResult(ConvertType(node.Type));
}

17
src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitor.cs

@ -224,9 +224,14 @@ namespace NRefactoryToBooConverter @@ -224,9 +224,14 @@ namespace NRefactoryToBooConverter
{
if (t == null || t.IsNull)
return null;
B.TypeReference r = new B.SimpleTypeReference(GetLexicalInfo(t), GetIntrinsicTypeName(t.SystemType));
B.TypeReference r;
if (t.GenericTypes.Count > 0) {
AddError(t, "Consuming generics is not supported by boo.");
r = new B.GenericTypeReference(GetLexicalInfo(t), GetIntrinsicTypeName(t.SystemType));
foreach (TypeReference ta in t.GenericTypes) {
((B.GenericTypeReference)r).GenericArguments.Add(ConvertTypeReference(ta));
}
} else {
r = new B.SimpleTypeReference(GetLexicalInfo(t), GetIntrinsicTypeName(t.SystemType));
}
if (t.IsArrayType) {
for (int i = t.RankSpecifier.Length - 1; i >= 0; --i) {
@ -251,14 +256,6 @@ namespace NRefactoryToBooConverter @@ -251,14 +256,6 @@ namespace NRefactoryToBooConverter
return null;
}
/// <summary>
/// Convert TypeReference and wrap it into an TypeofExpression.
/// </summary>
B.TypeofExpression WrapTypeReference(TypeReference t)
{
return new B.TypeofExpression(GetLexicalInfo(t), ConvertTypeReference(t));
}
public object Visit(TypeReference typeReference, object data)
{
return ConvertTypeReference(typeReference);

63
src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Project/ConvertVisitorExpressions.cs

@ -34,6 +34,24 @@ namespace NRefactoryToBooConverter @@ -34,6 +34,24 @@ namespace NRefactoryToBooConverter
return (B.Expression)expr.AcceptVisitor(this, null);
}
B.Expression MakeReferenceExpression(TypeReference typeRef)
{
if (typeRef.IsArrayType)
return new B.TypeofExpression(GetLexicalInfo(typeRef), ConvertTypeReference(typeRef));
B.SimpleTypeReference t = (B.SimpleTypeReference)ConvertTypeReference(typeRef);
B.ReferenceExpression r = MakeReferenceExpression(t.Name);
if (t is B.GenericTypeReference) {
B.GenericReferenceExpression gr = new B.GenericReferenceExpression(GetLexicalInfo(typeRef));
gr.Target = r;
foreach (B.TypeReference tr in ((B.GenericTypeReference)t).GenericArguments) {
gr.GenericArguments.Add(tr);
}
return gr;
} else {
return r;
}
}
B.ReferenceExpression MakeReferenceExpression(string fullName)
{
string[] parts = fullName.Split('.');
@ -112,10 +130,10 @@ namespace NRefactoryToBooConverter @@ -112,10 +130,10 @@ namespace NRefactoryToBooConverter
{
B.Expression target = null;
if (fre.TargetObject is TypeReferenceExpression) {
// not typeof, so this is something like int.Parse()
// not typeof, so this is something like int.Parse() or Class<string>.StaticMethod
TypeReference typeRef = ((TypeReferenceExpression)fre.TargetObject).TypeReference;
if (!typeRef.IsArrayType)
target = MakeReferenceExpression(typeRef.SystemType);
target = MakeReferenceExpression(typeRef);
}
if (target == null) {
target = (B.Expression)fre.TargetObject.AcceptVisitor(this, data);
@ -195,7 +213,6 @@ namespace NRefactoryToBooConverter @@ -195,7 +213,6 @@ namespace NRefactoryToBooConverter
switch (op) {
case BinaryOperatorType.Add:
return B.BinaryOperatorType.Addition;
//case BinaryOperatorType.AsCast: special case: converted to AsExpression
case BinaryOperatorType.BitwiseAnd:
return B.BinaryOperatorType.BitwiseAnd;
case BinaryOperatorType.BitwiseOr:
@ -242,8 +259,6 @@ namespace NRefactoryToBooConverter @@ -242,8 +259,6 @@ namespace NRefactoryToBooConverter
return B.BinaryOperatorType.ShiftRight;
case BinaryOperatorType.Subtract:
return B.BinaryOperatorType.Subtraction;
case BinaryOperatorType.TypeCheck:
return B.BinaryOperatorType.TypeTest;
default:
return B.BinaryOperatorType.None;
}
@ -278,12 +293,8 @@ namespace NRefactoryToBooConverter @@ -278,12 +293,8 @@ namespace NRefactoryToBooConverter
B.Expression right = ConvertExpression(binaryOperatorExpression.Right);
B.BinaryOperatorType op = ConvertOperator(binaryOperatorExpression.Op);
if (op == B.BinaryOperatorType.None) {
if (binaryOperatorExpression.Op == BinaryOperatorType.AsCast) {
return new B.AsExpression(GetLexicalInfo(binaryOperatorExpression), left, ConvertTypeReference(right));
} else {
AddError(binaryOperatorExpression, "Unknown operator.");
return null;
}
AddError(binaryOperatorExpression, "Unknown operator.");
return null;
}
// if (binaryOperatorExpression.Op == BinaryOperatorType.DivideInteger) {
// AddWarning(binaryOperatorExpression, "Integer division converted to normal division.");
@ -350,14 +361,14 @@ namespace NRefactoryToBooConverter @@ -350,14 +361,14 @@ namespace NRefactoryToBooConverter
if (t.SystemType.EndsWith("EventHandler") && objectCreateExpression.Parameters.Count == 1)
return ConvertExpression((Expression)objectCreateExpression.Parameters[0]);
B.MethodInvocationExpression mie = new B.MethodInvocationExpression(GetLexicalInfo(objectCreateExpression), MakeReferenceExpression(t.SystemType));
B.MethodInvocationExpression mie = new B.MethodInvocationExpression(GetLexicalInfo(objectCreateExpression), MakeReferenceExpression(t));
ConvertExpressions(objectCreateExpression.Parameters, mie.Arguments);
return mie;
}
public object Visit(TypeReferenceExpression typeReferenceExpression, object data)
{
return WrapTypeReference(typeReferenceExpression.TypeReference);
return MakeReferenceExpression(typeReferenceExpression.TypeReference);
}
public object Visit(SizeOfExpression sizeOfExpression, object data)
@ -381,7 +392,7 @@ namespace NRefactoryToBooConverter @@ -381,7 +392,7 @@ namespace NRefactoryToBooConverter
{
return new B.BinaryExpression(GetLexicalInfo(typeOfIsExpression), B.BinaryOperatorType.TypeTest,
ConvertExpression(typeOfIsExpression.Expression),
WrapTypeReference(typeOfIsExpression.TypeReference));
MakeReferenceExpression(typeOfIsExpression.TypeReference));
}
public object Visit(AddressOfExpression addressOfExpression, object data)
@ -398,9 +409,21 @@ namespace NRefactoryToBooConverter @@ -398,9 +409,21 @@ namespace NRefactoryToBooConverter
public object Visit(CastExpression castExpression, object data)
{
return new B.CastExpression(GetLexicalInfo(castExpression),
ConvertTypeReference(castExpression.CastTo),
ConvertExpression(castExpression.Expression));
switch (castExpression.CastType) {
case CastType.Cast:
case CastType.Conversion:
case CastType.PrimitiveConversion:
return new B.CastExpression(GetLexicalInfo(castExpression),
ConvertExpression(castExpression.Expression),
ConvertTypeReference(castExpression.CastTo));
case CastType.TryCast:
return new B.TryCastExpression(GetLexicalInfo(castExpression),
ConvertExpression(castExpression.Expression),
ConvertTypeReference(castExpression.CastTo));
default:
AddError(castExpression, "Unknown cast: " + castExpression);
return null;
}
}
public object Visit(StackAllocExpression stackAllocExpression, object data)
@ -438,11 +461,7 @@ namespace NRefactoryToBooConverter @@ -438,11 +461,7 @@ namespace NRefactoryToBooConverter
for (int i = 0; i < newRank.Length; i++)
newRank[i] = elementType.RankSpecifier[i + 1];
elementType.RankSpecifier = newRank;
if (newRank.Length == 0) {
mie.Arguments.Add(MakeReferenceExpression(elementType.SystemType));
} else {
mie.Arguments.Add(WrapTypeReference(elementType));
}
mie.Arguments.Add(MakeReferenceExpression(elementType));
if (arrayCreateExpression.Arguments.Count == 1) {
mie.Arguments.Add(ConvertExpression(arrayCreateExpression.Arguments[0]));
} else {

48
src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Test/ExpressionTests.cs

@ -31,6 +31,42 @@ namespace NRefactoryToBooConverter.Tests @@ -31,6 +31,42 @@ namespace NRefactoryToBooConverter.Tests
TestExpr("base.Member", "super.Member");
}
[Test]
public void CastExpression()
{
TestExpr("(TargetType)var", "cast(TargetType, var)");
}
[Test]
public void TryCastExpression()
{
TestExpr("var as TargetType", "(var as TargetType)");
}
[Test]
public void TypeTestExpression()
{
TestExpr("var is TargetType", "(var isa TargetType)");
}
[Test]
public void CastExpressionComplexType()
{
TestExpr("(List<T>[,])var", "cast((List[of T], 2), var)");
}
[Test]
public void TryCastExpressionComplexType()
{
TestExpr("var as List<T>[,]", "(var as (List[of T], 2))");
}
[Test, Ignore("Boo uses BinaryOperatorExpression for isa")]
public void TypeTestExpressionComplexType()
{
TestExpr("var is List<T>[,]", "(var isa (List[of T], 2))");
}
[Test]
public void Reference()
{
@ -61,12 +97,24 @@ namespace NRefactoryToBooConverter.Tests @@ -61,12 +97,24 @@ namespace NRefactoryToBooConverter.Tests
TestExpr("new MainClass()", "MainClass()");
}
[Test]
public void GenericObjectConstruction()
{
TestExpr("new List<Element>()", "List[of Element]()");
}
[Test]
public void QualifiedConstruction()
{
TestExpr("new System.DefaultComparer()", "System.DefaultComparer()");
}
[Test]
public void QualifiedGenericObjectConstruction()
{
TestExpr("new Namespace.List<System.Element>()", "Namespace.List[of System.Element]()");
}
[Test]
public void Integer()
{

7
src/AddIns/BackendBindings/Boo/NRefactoryToBooConverter/Test/MemberTests.cs

@ -73,6 +73,13 @@ namespace NRefactoryToBooConverter.Tests @@ -73,6 +73,13 @@ namespace NRefactoryToBooConverter.Tests
TestInClass("System.IDisposable d;", "private d as System.IDisposable");
}
[Test]
public void GenericField()
{
TestInClass("Dictionary<Dictionary<T, List<K>>, List<J>> d;",
"private d as Dictionary[of Dictionary[of T, List[of K]], List[of J]]");
}
[Test]
public void FieldWithInitializer()
{

10
src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlView.cs

@ -173,7 +173,7 @@ namespace ICSharpCode.XmlEditor @@ -173,7 +173,7 @@ namespace ICSharpCode.XmlEditor
}
public override void Dispose()
{
{
base.Dispose();
((Form)ICSharpCode.SharpDevelop.Gui.WorkbenchSingleton.Workbench).Activated -= new EventHandler(GotFocusEvent);
@ -222,7 +222,7 @@ namespace ICSharpCode.XmlEditor @@ -222,7 +222,7 @@ namespace ICSharpCode.XmlEditor
{
try {
WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView)).BringPadToFront();
TaskService.ClearExceptCommentTasks();
if (IsWellFormed) {
@ -401,7 +401,7 @@ namespace ICSharpCode.XmlEditor @@ -401,7 +401,7 @@ namespace ICSharpCode.XmlEditor
public void ParseInformationUpdated(ParseInformation parseInfo)
{
xmlEditor.BeginInvoke(new MethodInvoker(UpdateFolding));
WorkbenchSingleton.SafeThreadAsyncCall(this, "UpdateFolding");
}
#endregion
@ -627,7 +627,7 @@ namespace ICSharpCode.XmlEditor @@ -627,7 +627,7 @@ namespace ICSharpCode.XmlEditor
/// </summary>
void ShowOutputWindow()
{
WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView)).BringPadToFront();
WorkbenchSingleton.Workbench.GetPad(typeof(CompilerMessageView)).BringPadToFront();
}
/// <summary>
@ -757,7 +757,7 @@ namespace ICSharpCode.XmlEditor @@ -757,7 +757,7 @@ namespace ICSharpCode.XmlEditor
XslCompiledTransform xslTransform = new XslCompiledTransform();
xslTransform.Load(transformDocument, XsltSettings.Default, new XmlUrlResolver());
MemoryStream outputStream = new MemoryStream();
XmlTextWriter writer = new XmlTextWriter(outputStream, Encoding.UTF8);

2
src/AddIns/Misc/Debugger/Debugger.AddIn/Project/Src/Service/DynamicTreeDebuggerRow.cs

@ -45,7 +45,7 @@ namespace ICSharpCode.SharpDevelop.Services @@ -45,7 +45,7 @@ namespace ICSharpCode.SharpDevelop.Services
this[3].Text = variable.Value.AsString;
this[1].Paint += delegate(object sender, ItemPaintEventArgs e) {
e.Graphics.DrawImage(DebuggerIcons.GetImage(variable), e.ClipRectangle);
e.Graphics.DrawImageUnscaled(DebuggerIcons.GetImage(variable), e.ClipRectangle);
};
if (!variable.Value.MayHaveSubVariables)

6
src/Libraries/ICSharpCode.TextEditor/Project/Resources/Boo.xshd

@ -181,6 +181,10 @@ @@ -181,6 +181,10 @@
<Key word="void"/>
</KeyWords>
<KeyWords name="Of" bold="true" italic="false" color="Blue" >
<Key word="of"/>
</KeyWords>
<KeyWords name="ConversionKeyWords" bold="true" italic="false" color="Blue" >
<Key word="cast"/>
<Key word="as"/>
@ -193,6 +197,7 @@ @@ -193,6 +197,7 @@
<Key word="abstract"/>
<Key word="final"/>
<Key word="transient"/>
<Key word="partial"/>
</KeyWords>
<KeyWords name="AccessModifiers" bold="true" italic="false" color="Blue" >
@ -230,6 +235,7 @@ @@ -230,6 +235,7 @@
<Key word="required"/>
<Key word="rawArrayIndexing"/>
<Key word="normalArrayIndexing"/>
<Key word="yieldAll" />
</KeyWords>
<KeyWords name="Builtins" bold="false" italic="false" color="Purple" >

30
src/Libraries/NRefactory/Project/Src/Output/CSharp/CSharpOutputVisitor.cs

@ -1815,18 +1815,6 @@ namespace ICSharpCode.NRefactory.PrettyPrinter @@ -1815,18 +1815,6 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
}
break;
case BinaryOperatorType.AsCast:
outputFormatter.Space();
outputFormatter.PrintToken(Tokens.As);
outputFormatter.Space();
break;
case BinaryOperatorType.TypeCheck:
outputFormatter.Space();
outputFormatter.PrintToken(Tokens.Is);
outputFormatter.Space();
break;
case BinaryOperatorType.Equality:
case BinaryOperatorType.ReferenceEquality:
if (prettyPrintOptions.AroundRelationalOperatorParentheses) {
@ -2158,13 +2146,21 @@ namespace ICSharpCode.NRefactory.PrettyPrinter @@ -2158,13 +2146,21 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
public object Visit(CastExpression castExpression, object data)
{
outputFormatter.PrintToken(Tokens.OpenParenthesis);
nodeTracker.TrackedVisit(castExpression.CastTo, data);
outputFormatter.PrintToken(Tokens.CloseParenthesis);
if (this.prettyPrintOptions.SpacesAfterTypeCast) {
if (castExpression.CastType == CastType.TryCast) {
nodeTracker.TrackedVisit(castExpression.Expression, data);
outputFormatter.Space();
outputFormatter.PrintToken(Tokens.As);
outputFormatter.Space();
nodeTracker.TrackedVisit(castExpression.CastTo, data);
} else {
outputFormatter.PrintToken(Tokens.OpenParenthesis);
nodeTracker.TrackedVisit(castExpression.CastTo, data);
outputFormatter.PrintToken(Tokens.CloseParenthesis);
if (this.prettyPrintOptions.SpacesAfterTypeCast) {
outputFormatter.Space();
}
nodeTracker.TrackedVisit(castExpression.Expression, data);
}
nodeTracker.TrackedVisit(castExpression.Expression, data);
return null;
}

5
src/Libraries/NRefactory/Project/Src/Output/CodeDOM/CodeDOMOutputVisitor.cs

@ -596,11 +596,6 @@ namespace ICSharpCode.NRefactory.Parser @@ -596,11 +596,6 @@ namespace ICSharpCode.NRefactory.Parser
case BinaryOperatorType.ReferenceInequality:
op = CodeBinaryOperatorType.IdentityInequality;
break;
case BinaryOperatorType.AsCast:
case BinaryOperatorType.TypeCheck:
// CodeDOM suxx
op = CodeBinaryOperatorType.Add;
break;
case BinaryOperatorType.ExclusiveOr:
// TODO ExclusiveOr

41
src/Libraries/NRefactory/Project/Src/Output/VBNet/VBNetOutputVisitor.cs

@ -1840,20 +1840,6 @@ namespace ICSharpCode.NRefactory.PrettyPrinter @@ -1840,20 +1840,6 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
op = Tokens.IsNot;
break;
case BinaryOperatorType.AsCast:
outputFormatter.PrintText("TryCast(");
nodeTracker.TrackedVisit(binaryOperatorExpression.Left, data);
outputFormatter.PrintText(", ");
nodeTracker.TrackedVisit(binaryOperatorExpression.Right, data);
outputFormatter.PrintText(")");
return null;
case BinaryOperatorType.TypeCheck:
outputFormatter.PrintText("TypeOf ");
nodeTracker.TrackedVisit(binaryOperatorExpression.Left, data);
outputFormatter.PrintText(" Is ");
nodeTracker.TrackedVisit(binaryOperatorExpression.Right, data);
return null;
case BinaryOperatorType.Equality:
op = Tokens.Assign;
break;
@ -2135,6 +2121,12 @@ namespace ICSharpCode.NRefactory.PrettyPrinter @@ -2135,6 +2121,12 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
public object Visit(CastExpression castExpression, object data)
{
if (castExpression.CastType == CastType.Cast) {
return PrintCast(Tokens.DirectCast, castExpression);
}
if (castExpression.CastType == CastType.TryCast) {
return PrintCast(Tokens.TryCast, castExpression);
}
switch (castExpression.CastTo.SystemType) {
case "System.Boolean":
outputFormatter.PrintToken(Tokens.CBool);
@ -2185,14 +2177,7 @@ namespace ICSharpCode.NRefactory.PrettyPrinter @@ -2185,14 +2177,7 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
outputFormatter.PrintToken(Tokens.CStr);
break;
default:
outputFormatter.PrintToken(Tokens.CType);
outputFormatter.PrintToken(Tokens.OpenParenthesis);
nodeTracker.TrackedVisit(castExpression.Expression, data);
outputFormatter.PrintToken(Tokens.Comma);
outputFormatter.Space();
nodeTracker.TrackedVisit(castExpression.CastTo, data);
outputFormatter.PrintToken(Tokens.CloseParenthesis);
return null;
return PrintCast(Tokens.CType, castExpression);
}
outputFormatter.PrintToken(Tokens.OpenParenthesis);
nodeTracker.TrackedVisit(castExpression.Expression, data);
@ -2200,6 +2185,18 @@ namespace ICSharpCode.NRefactory.PrettyPrinter @@ -2200,6 +2185,18 @@ namespace ICSharpCode.NRefactory.PrettyPrinter
return null;
}
object PrintCast(int castToken, CastExpression castExpression)
{
outputFormatter.PrintToken(castToken);
outputFormatter.PrintToken(Tokens.OpenParenthesis);
nodeTracker.TrackedVisit(castExpression.Expression, null);
outputFormatter.PrintToken(Tokens.Comma);
outputFormatter.Space();
nodeTracker.TrackedVisit(castExpression.CastTo, null);
outputFormatter.PrintToken(Tokens.CloseParenthesis);
return null;
}
public object Visit(StackAllocExpression stackAllocExpression, object data)
{
errors.Error(-1, -1, String.Format("StackAllocExpression is unsupported"));

5
src/Libraries/NRefactory/Project/Src/Parser/AST/General/Expressions/BinaryOperatorExpression.cs

@ -64,10 +64,7 @@ namespace ICSharpCode.NRefactory.Parser.AST @@ -64,10 +64,7 @@ namespace ICSharpCode.NRefactory.Parser.AST
ReferenceEquality,
/// <summary>VB-only: IsNot</summary>
ReferenceInequality,
/// <summary>C#: Is</summary>
TypeCheck,
/// <summary>'as' in C#, 'TryCast(l, r)' in VB</summary>
AsCast,
/// <summary>VB-only: Like</summary>
Like,
/// <summary>C#: ??</summary>

37
src/Libraries/NRefactory/Project/Src/Parser/AST/General/Expressions/CastExpression.cs

@ -11,11 +11,31 @@ using System.Collections; @@ -11,11 +11,31 @@ using System.Collections;
namespace ICSharpCode.NRefactory.Parser.AST
{
public enum CastType
{
/// <summary>
/// direct cast (C#, VB "DirectCast")
/// </summary>
Cast,
/// <summary>
/// try cast (C# "as", VB "TryCast")
/// </summary>
TryCast,
/// <summary>
/// converting cast (VB "CType")
/// </summary>
Conversion,
/// <summary>
/// primitive converting cast (VB "CString" etc.)
/// </summary>
PrimitiveConversion
}
public class CastExpression : Expression
{
TypeReference castTo;
Expression expression;
bool isSpecializedCast = false;
CastType castType;
public TypeReference CastTo {
get {
@ -35,12 +55,12 @@ namespace ICSharpCode.NRefactory.Parser.AST @@ -35,12 +55,12 @@ namespace ICSharpCode.NRefactory.Parser.AST
}
}
public bool IsSpecializedCast {
public CastType CastType {
get {
return isSpecializedCast;
return castType;
}
set {
isSpecializedCast = value;
castType = value;
}
}
@ -56,11 +76,11 @@ namespace ICSharpCode.NRefactory.Parser.AST @@ -56,11 +76,11 @@ namespace ICSharpCode.NRefactory.Parser.AST
this.Expression = expression;
}
public CastExpression(TypeReference castTo, Expression expression, bool isSpecializedCast)
public CastExpression(TypeReference castTo, Expression expression, CastType castType)
{
this.CastTo = castTo;
this.Expression = expression;
this.isSpecializedCast = isSpecializedCast;
this.castType = castType;
}
@ -71,9 +91,10 @@ namespace ICSharpCode.NRefactory.Parser.AST @@ -71,9 +91,10 @@ namespace ICSharpCode.NRefactory.Parser.AST
public override string ToString()
{
return String.Format("[CastExpression: CastTo={0}, Expression={1}]",
return String.Format("[CastExpression: CastTo={0}, Expression={1} CastType={2}]",
castTo,
expression);
expression,
castType);
}
}
}

16
src/Libraries/NRefactory/Project/Src/Parser/AST/VBNet/Expressions/TypeOfIsExpression.cs

@ -11,8 +11,19 @@ using System.Collections; @@ -11,8 +11,19 @@ using System.Collections;
namespace ICSharpCode.NRefactory.Parser.AST
{
public class TypeOfIsExpression : TypeOfExpression
public class TypeOfIsExpression : Expression
{
TypeReference typeReference;
public TypeReference TypeReference {
get {
return typeReference;
}
set {
typeReference = TypeReference.CheckNull(value);
}
}
Expression expression;
public Expression Expression {
@ -24,9 +35,10 @@ namespace ICSharpCode.NRefactory.Parser.AST @@ -24,9 +35,10 @@ namespace ICSharpCode.NRefactory.Parser.AST
}
}
public TypeOfIsExpression(Expression expression, TypeReference typeReference) : base(typeReference)
public TypeOfIsExpression(Expression expression, TypeReference typeReference)
{
this.Expression = expression;
this.TypeReference = typeReference;
}
public override object AcceptVisitor(IASTVisitor visitor, object data)

176
src/Libraries/NRefactory/Project/Src/Parser/CSharp/Parser.cs

@ -1305,39 +1305,39 @@ templates); @@ -1305,39 +1305,39 @@ templates);
}
void TypeParameterList(
#line 2452 "cs.ATG"
#line 2454 "cs.ATG"
List<TemplateDefinition> templates) {
#line 2454 "cs.ATG"
#line 2456 "cs.ATG"
AttributeSection section;
List<AttributeSection> attributes = new List<AttributeSection>();
Expect(23);
while (la.kind == 18) {
AttributeSection(
#line 2458 "cs.ATG"
#line 2460 "cs.ATG"
out section);
#line 2458 "cs.ATG"
#line 2460 "cs.ATG"
attributes.Add(section);
}
Expect(1);
#line 2459 "cs.ATG"
#line 2461 "cs.ATG"
templates.Add(new TemplateDefinition(t.val, attributes));
while (la.kind == 14) {
lexer.NextToken();
while (la.kind == 18) {
AttributeSection(
#line 2460 "cs.ATG"
#line 2462 "cs.ATG"
out section);
#line 2460 "cs.ATG"
#line 2462 "cs.ATG"
attributes.Add(section);
}
Expect(1);
#line 2461 "cs.ATG"
#line 2463 "cs.ATG"
templates.Add(new TemplateDefinition(t.val, attributes));
}
Expect(22);
@ -1370,25 +1370,25 @@ out typeRef, false); @@ -1370,25 +1370,25 @@ out typeRef, false);
}
void TypeParameterConstraintsClause(
#line 2465 "cs.ATG"
#line 2467 "cs.ATG"
List<TemplateDefinition> templates) {
#line 2466 "cs.ATG"
#line 2468 "cs.ATG"
string name = ""; TypeReference type;
Expect(1);
#line 2468 "cs.ATG"
#line 2470 "cs.ATG"
if (t.val != "where") Error("where expected");
Expect(1);
#line 2469 "cs.ATG"
#line 2471 "cs.ATG"
name = t.val;
Expect(9);
TypeParameterConstraintsClauseBase(
#line 2471 "cs.ATG"
#line 2473 "cs.ATG"
out type);
#line 2472 "cs.ATG"
#line 2474 "cs.ATG"
TemplateDefinition td = null;
foreach (TemplateDefinition d in templates) {
if (d.Name == name) {
@ -1401,10 +1401,10 @@ out type); @@ -1401,10 +1401,10 @@ out type);
while (la.kind == 14) {
lexer.NextToken();
TypeParameterConstraintsClauseBase(
#line 2481 "cs.ATG"
#line 2483 "cs.ATG"
out type);
#line 2482 "cs.ATG"
#line 2484 "cs.ATG"
td = null;
foreach (TemplateDefinition d in templates) {
if (d.Name == name) {
@ -1744,33 +1744,33 @@ out r, canBeUnbound); @@ -1744,33 +1744,33 @@ out r, canBeUnbound);
}
void TypeName(
#line 2395 "cs.ATG"
#line 2397 "cs.ATG"
out TypeReference typeRef, bool canBeUnbound) {
#line 2396 "cs.ATG"
#line 2398 "cs.ATG"
List<TypeReference> typeArguments = null;
string alias = null;
string qualident;
if (
#line 2401 "cs.ATG"
#line 2403 "cs.ATG"
la.kind == Tokens.Identifier && Peek(1).kind == Tokens.DoubleColon) {
lexer.NextToken();
#line 2402 "cs.ATG"
#line 2404 "cs.ATG"
alias = t.val;
Expect(10);
}
Qualident(
#line 2405 "cs.ATG"
#line 2407 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
#line 2406 "cs.ATG"
#line 2408 "cs.ATG"
out typeArguments, canBeUnbound);
}
#line 2408 "cs.ATG"
#line 2410 "cs.ATG"
if (alias == null) {
typeRef = new TypeReference(qualident, typeArguments);
} else if (alias == "global") {
@ -1781,22 +1781,22 @@ out typeArguments, canBeUnbound); @@ -1781,22 +1781,22 @@ out typeArguments, canBeUnbound);
}
while (
#line 2417 "cs.ATG"
#line 2419 "cs.ATG"
DotAndIdent()) {
Expect(15);
#line 2418 "cs.ATG"
#line 2420 "cs.ATG"
typeArguments = null;
Qualident(
#line 2419 "cs.ATG"
#line 2421 "cs.ATG"
out qualident);
if (la.kind == 23) {
TypeArgumentList(
#line 2420 "cs.ATG"
#line 2422 "cs.ATG"
out typeArguments, canBeUnbound);
}
#line 2421 "cs.ATG"
#line 2423 "cs.ATG"
typeRef = new InnerClassTypeReference(typeRef, qualident, typeArguments);
}
}
@ -2836,14 +2836,14 @@ out name); @@ -2836,14 +2836,14 @@ out name);
}
void NullableQuestionMark(
#line 2426 "cs.ATG"
#line 2428 "cs.ATG"
ref TypeReference typeRef) {
#line 2427 "cs.ATG"
#line 2429 "cs.ATG"
List<TypeReference> typeArguments = new List<TypeReference>(1);
Expect(12);
#line 2431 "cs.ATG"
#line 2433 "cs.ATG"
if (typeRef != null) typeArguments.Add(typeRef);
typeRef = new TypeReference("System.Nullable", typeArguments);
@ -5157,40 +5157,40 @@ out stmt); @@ -5157,40 +5157,40 @@ out stmt);
}
void TypeArgumentList(
#line 2436 "cs.ATG"
#line 2438 "cs.ATG"
out List<TypeReference> types, bool canBeUnbound) {
#line 2438 "cs.ATG"
#line 2440 "cs.ATG"
types = new List<TypeReference>();
TypeReference type = null;
Expect(23);
if (
#line 2443 "cs.ATG"
#line 2445 "cs.ATG"
canBeUnbound && (la.kind == Tokens.GreaterThan || la.kind == Tokens.Comma)) {
#line 2444 "cs.ATG"
#line 2446 "cs.ATG"
types.Add(TypeReference.Null);
while (la.kind == 14) {
lexer.NextToken();
#line 2445 "cs.ATG"
#line 2447 "cs.ATG"
types.Add(TypeReference.Null);
}
} else if (StartOf(9)) {
Type(
#line 2446 "cs.ATG"
#line 2448 "cs.ATG"
out type);
#line 2446 "cs.ATG"
#line 2448 "cs.ATG"
types.Add(type);
while (la.kind == 14) {
lexer.NextToken();
Type(
#line 2447 "cs.ATG"
#line 2449 "cs.ATG"
out type);
#line 2447 "cs.ATG"
#line 2449 "cs.ATG"
types.Add(type);
}
} else SynErr(185);
@ -5341,133 +5341,133 @@ ref outExpr); @@ -5341,133 +5341,133 @@ ref outExpr);
if (la.kind == 23) {
lexer.NextToken();
#line 2328 "cs.ATG"
#line 2327 "cs.ATG"
op = BinaryOperatorType.LessThan;
} else if (la.kind == 22) {
lexer.NextToken();
#line 2329 "cs.ATG"
#line 2328 "cs.ATG"
op = BinaryOperatorType.GreaterThan;
} else if (la.kind == 36) {
lexer.NextToken();
#line 2330 "cs.ATG"
#line 2329 "cs.ATG"
op = BinaryOperatorType.LessThanOrEqual;
} else if (la.kind == 35) {
lexer.NextToken();
#line 2331 "cs.ATG"
#line 2330 "cs.ATG"
op = BinaryOperatorType.GreaterThanOrEqual;
} else SynErr(186);
UnaryExpr(
#line 2333 "cs.ATG"
#line 2332 "cs.ATG"
out expr);
ShiftExpr(
#line 2333 "cs.ATG"
ref expr);
#line 2333 "cs.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
#line 2334 "cs.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
} else {
if (la.kind == 84) {
lexer.NextToken();
TypeWithRestriction(
#line 2337 "cs.ATG"
out type, false, false);
#line 2336 "cs.ATG"
op = BinaryOperatorType.TypeCheck;
#line 2338 "cs.ATG"
outExpr = new TypeOfIsExpression(outExpr, type);
} else if (la.kind == 49) {
lexer.NextToken();
#line 2337 "cs.ATG"
op = BinaryOperatorType.AsCast;
} else SynErr(187);
TypeWithRestriction(
#line 2339 "cs.ATG"
TypeWithRestriction(
#line 2340 "cs.ATG"
out type, false, false);
#line 2340 "cs.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, new TypeReferenceExpression(type));
#line 2341 "cs.ATG"
outExpr = new CastExpression(type, outExpr, CastType.TryCast);
} else SynErr(187);
}
}
}
void ShiftExpr(
#line 2344 "cs.ATG"
#line 2346 "cs.ATG"
ref Expression outExpr) {
#line 2346 "cs.ATG"
#line 2348 "cs.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
AdditiveExpr(
#line 2350 "cs.ATG"
#line 2352 "cs.ATG"
ref outExpr);
while (la.kind == 37 ||
#line 2353 "cs.ATG"
#line 2355 "cs.ATG"
IsShiftRight()) {
if (la.kind == 37) {
lexer.NextToken();
#line 2352 "cs.ATG"
#line 2354 "cs.ATG"
op = BinaryOperatorType.ShiftLeft;
} else {
Expect(22);
Expect(22);
#line 2354 "cs.ATG"
#line 2356 "cs.ATG"
op = BinaryOperatorType.ShiftRight;
}
UnaryExpr(
#line 2357 "cs.ATG"
#line 2359 "cs.ATG"
out expr);
AdditiveExpr(
#line 2357 "cs.ATG"
#line 2359 "cs.ATG"
ref expr);
#line 2357 "cs.ATG"
#line 2359 "cs.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void AdditiveExpr(
#line 2361 "cs.ATG"
#line 2363 "cs.ATG"
ref Expression outExpr) {
#line 2363 "cs.ATG"
#line 2365 "cs.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
MultiplicativeExpr(
#line 2367 "cs.ATG"
#line 2369 "cs.ATG"
ref outExpr);
while (la.kind == 4 || la.kind == 5) {
if (la.kind == 4) {
lexer.NextToken();
#line 2370 "cs.ATG"
#line 2372 "cs.ATG"
op = BinaryOperatorType.Add;
} else {
lexer.NextToken();
#line 2371 "cs.ATG"
#line 2373 "cs.ATG"
op = BinaryOperatorType.Subtract;
}
UnaryExpr(
#line 2373 "cs.ATG"
#line 2375 "cs.ATG"
out expr);
MultiplicativeExpr(
#line 2373 "cs.ATG"
#line 2375 "cs.ATG"
ref expr);
#line 2373 "cs.ATG"
#line 2375 "cs.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void MultiplicativeExpr(
#line 2377 "cs.ATG"
#line 2379 "cs.ATG"
ref Expression outExpr) {
#line 2379 "cs.ATG"
#line 2381 "cs.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
@ -5475,57 +5475,57 @@ ref Expression outExpr) { @@ -5475,57 +5475,57 @@ ref Expression outExpr) {
if (la.kind == 6) {
lexer.NextToken();
#line 2385 "cs.ATG"
#line 2387 "cs.ATG"
op = BinaryOperatorType.Multiply;
} else if (la.kind == 7) {
lexer.NextToken();
#line 2386 "cs.ATG"
#line 2388 "cs.ATG"
op = BinaryOperatorType.Divide;
} else {
lexer.NextToken();
#line 2387 "cs.ATG"
#line 2389 "cs.ATG"
op = BinaryOperatorType.Modulus;
}
UnaryExpr(
#line 2389 "cs.ATG"
#line 2391 "cs.ATG"
out expr);
#line 2389 "cs.ATG"
#line 2391 "cs.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void TypeParameterConstraintsClauseBase(
#line 2493 "cs.ATG"
#line 2495 "cs.ATG"
out TypeReference type) {
#line 2494 "cs.ATG"
#line 2496 "cs.ATG"
TypeReference t; type = null;
if (la.kind == 108) {
lexer.NextToken();
#line 2496 "cs.ATG"
#line 2498 "cs.ATG"
type = new TypeReference("struct");
} else if (la.kind == 58) {
lexer.NextToken();
#line 2497 "cs.ATG"
#line 2499 "cs.ATG"
type = new TypeReference("struct");
} else if (la.kind == 88) {
lexer.NextToken();
Expect(20);
Expect(21);
#line 2498 "cs.ATG"
#line 2500 "cs.ATG"
type = new TypeReference("struct");
} else if (StartOf(9)) {
Type(
#line 2499 "cs.ATG"
#line 2501 "cs.ATG"
out t);
#line 2499 "cs.ATG"
#line 2501 "cs.ATG"
type = t;
} else SynErr(188);
}

26
src/Libraries/NRefactory/Project/Src/Parser/CSharp/cs.ATG

@ -2324,20 +2324,22 @@ RelationalExpr<ref Expression outExpr> @@ -2324,20 +2324,22 @@ RelationalExpr<ref Expression outExpr>
=
ShiftExpr<ref outExpr>
{
(
"<" (. op = BinaryOperatorType.LessThan; .)
| ">" (. op = BinaryOperatorType.GreaterThan; .)
| "<=" (. op = BinaryOperatorType.LessThanOrEqual; .)
| ">=" (. op = BinaryOperatorType.GreaterThanOrEqual; .)
( "<" (. op = BinaryOperatorType.LessThan; .)
| ">" (. op = BinaryOperatorType.GreaterThan; .)
| "<=" (. op = BinaryOperatorType.LessThanOrEqual; .)
| ">=" (. op = BinaryOperatorType.GreaterThanOrEqual; .)
)
UnaryExpr<out expr> ShiftExpr<ref expr> (. outExpr = new BinaryOperatorExpression(outExpr, op, expr); .)
|
(
"is" (. op = BinaryOperatorType.TypeCheck; .)
| "as" (. op = BinaryOperatorType.AsCast; .)
UnaryExpr<out expr>
ShiftExpr<ref expr>
(. outExpr = new BinaryOperatorExpression(outExpr, op, expr); .)
|
( "is"
TypeWithRestriction<out type, false, false>
(. outExpr = new TypeOfIsExpression(outExpr, type); .)
| "as"
TypeWithRestriction<out type, false, false>
(. outExpr = new CastExpression(type, outExpr, CastType.TryCast); .)
)
TypeWithRestriction<out type, false, false>
(. outExpr = new BinaryOperatorExpression(outExpr, op, new TypeReferenceExpression(type)); .)
}
.

1151
src/Libraries/NRefactory/Project/Src/Parser/VBNet/Parser.cs

File diff suppressed because it is too large Load Diff

12
src/Libraries/NRefactory/Project/Src/Parser/VBNet/VBNET.ATG

@ -1777,9 +1777,15 @@ SimpleExpr<out Expression pexpr> @@ -1777,9 +1777,15 @@ SimpleExpr<out Expression pexpr>
(. type.IsGlobal = true; .)
(. pexpr = new TypeReferenceExpression(type); .)
| ObjectCreateExpression<out expr> (. pexpr = expr; .)
| /* 11.11 */ ( "DirectCast" | "CType" ) "(" Expr<out expr> "," TypeName<out type> ")" (. pexpr = new CastExpression(type, expr); .)
| /* 11.11 */ "TryCast" "(" Expr<out expr> "," TypeName<out type> ")" (. pexpr = new BinaryOperatorExpression(expr, BinaryOperatorType.AsCast, new TypeReferenceExpression(type)); .)
| /* 11.11 */ CastTarget<out type> "(" Expr<out expr> ")" (. pexpr = new CastExpression(type, expr, true); .)
| /* 11.11 : Casts */
(. CastType castType = CastType.Cast; .)
( "DirectCast"
| "CType" (. castType = CastType.Conversion; .)
| "TryCast" (. castType = CastType.TryCast; .)
)
"(" Expr<out expr> "," TypeName<out type> ")"
(. pexpr = new CastExpression(type, expr, castType); .)
| /* 11.11 */ CastTarget<out type> "(" Expr<out expr> ")" (. pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion); .)
| /* 11.4.5 */ "AddressOf" Expr<out expr> (. pexpr = new AddressOfExpression(expr); .)
| /* 11.5.1 */ "GetType" "(" GetTypeTypeName<out type> ")" (. pexpr = new TypeOfExpression(type); .)
| /* 11.5.2 */ "TypeOf" SimpleExpr<out expr> "Is" TypeName<out type> (. pexpr = new TypeOfIsExpression(expr, type); .)

12
src/Libraries/NRefactory/Test/Output/CSharp/CSharpOutputTest.cs

@ -151,6 +151,18 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter @@ -151,6 +151,18 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
TestExpression("GenericMethod<T>(arg)");
}
[Test]
public void Cast()
{
TestExpression("(T)a");
}
[Test]
public void AsCast()
{
TestExpression("a as T");
}
[Test]
public void NullCoalescing()
{

24
src/Libraries/NRefactory/Test/Output/VBNet/VBNetOutputTest.cs

@ -149,5 +149,29 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter @@ -149,5 +149,29 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
{
TestStatement("Using a As A = New A()\na.Work()\nEnd Using");
}
[Test]
public void Cast()
{
TestExpression("CType(a, T)");
}
[Test]
public void DirectCast()
{
TestExpression("DirectCast(a, T)");
}
[Test]
public void TryCast()
{
TestExpression("TryCast(a, T)");
}
[Test]
public void PrimitiveCast()
{
TestExpression("CStr(a)");
}
}
}

20
src/Libraries/NRefactory/Test/Parser/Expressions/BinaryOperatorExpressionTests.cs

@ -142,26 +142,6 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -142,26 +142,6 @@ namespace ICSharpCode.NRefactory.Tests.AST
{
CSharpTestBinaryOperatorExpressionTest("a ?? b", BinaryOperatorType.NullCoalescing);
}
[Test]
public void CSharpISTest()
{
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("a is b");
Assert.AreEqual(BinaryOperatorType.TypeCheck, boe.Op);
Assert.IsTrue(boe.Left is IdentifierExpression);
Assert.IsTrue(boe.Right is TypeReferenceExpression);
}
[Test]
public void CSharpASTest()
{
BinaryOperatorExpression boe = ParseUtilCSharp.ParseExpression<BinaryOperatorExpression>("a as b");
Assert.AreEqual(BinaryOperatorType.AsCast, boe.Op);
Assert.IsTrue(boe.Left is IdentifierExpression);
Assert.IsTrue(boe.Right is TypeReferenceExpression);
}
#endregion
#region VB.NET

75
src/Libraries/NRefactory/Test/Parser/Expressions/CastExpressionTests.cs

@ -1,4 +1,4 @@ @@ -1,4 +1,4 @@
// <file>
// <file>
// <copyright see="prj:///doc/copyright.txt">2002-2005 AlphaSierraPapa</copyright>
// <license see="prj:///doc/license.txt">GNU General Public License</license>
// <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@ -23,7 +23,7 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -23,7 +23,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(MyObject)o");
Assert.AreEqual("MyObject", ce.CastTo.Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.IsFalse(ce.IsSpecializedCast);
Assert.AreEqual(CastType.Cast, ce.CastType);
}
[Test]
@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
Assert.AreEqual("MyType", ce.CastTo.Type);
Assert.AreEqual(new int[] { 0 }, ce.CastTo.RankSpecifier);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.IsFalse(ce.IsSpecializedCast);
Assert.AreEqual(CastType.Cast, ce.CastType);
}
[Test]
@ -43,7 +43,7 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -43,7 +43,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
Assert.AreEqual("List", ce.CastTo.Type);
Assert.AreEqual("string", ce.CastTo.GenericTypes[0].Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.IsFalse(ce.IsSpecializedCast);
Assert.AreEqual(CastType.Cast, ce.CastType);
}
[Test]
@ -54,7 +54,18 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -54,7 +54,18 @@ namespace ICSharpCode.NRefactory.Tests.AST
Assert.AreEqual("string", ce.CastTo.GenericTypes[0].Type);
Assert.AreEqual(new int[] { 0 }, ce.CastTo.RankSpecifier);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.IsFalse(ce.IsSpecializedCast);
Assert.AreEqual(CastType.Cast, ce.CastType);
}
[Test]
public void GenericArrayAsCastExpression()
{
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("o as List<string>[]");
Assert.AreEqual("List", ce.CastTo.Type);
Assert.AreEqual("string", ce.CastTo.GenericTypes[0].Type);
Assert.AreEqual(new int[] { 0 }, ce.CastTo.RankSpecifier);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.AreEqual(CastType.TryCast, ce.CastType);
}
[Test]
@ -64,7 +75,7 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -64,7 +75,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
CastExpression ce = ParseUtilCSharp.ParseExpression<CastExpression>("(MyType)(expr).Member");
Assert.AreEqual("MyType", ce.CastTo.Type);
Assert.IsTrue(ce.Expression is FieldReferenceExpression);
Assert.IsFalse(ce.IsSpecializedCast);
Assert.AreEqual(CastType.Cast, ce.CastType);
}
#endregion
@ -74,7 +85,7 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -74,7 +85,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
CastExpression ce = ParseUtilVBNet.ParseExpression<CastExpression>(castExpression);
Assert.AreEqual(castType.FullName, ce.CastTo.Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.IsTrue(ce.IsSpecializedCast);
Assert.AreEqual(CastType.PrimitiveConversion, ce.CastType);
}
@ -84,7 +95,55 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -84,7 +95,55 @@ namespace ICSharpCode.NRefactory.Tests.AST
CastExpression ce = ParseUtilVBNet.ParseExpression<CastExpression>("CType(o, MyObject)");
Assert.AreEqual("MyObject", ce.CastTo.Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.IsFalse(ce.IsSpecializedCast);
Assert.AreEqual(CastType.Conversion, ce.CastType);
}
[Test]
public void VBNetGenericCastExpression()
{
CastExpression ce = ParseUtilVBNet.ParseExpression<CastExpression>("CType(o, List(of T))");
Assert.AreEqual("List", ce.CastTo.Type);
Assert.AreEqual("T", ce.CastTo.GenericTypes[0].Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.AreEqual(CastType.Conversion, ce.CastType);
}
[Test]
public void VBNetSimpleDirectCastExpression()
{
CastExpression ce = ParseUtilVBNet.ParseExpression<CastExpression>("DirectCast(o, MyObject)");
Assert.AreEqual("MyObject", ce.CastTo.Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.AreEqual(CastType.Cast, ce.CastType);
}
[Test]
public void VBNetGenericDirectCastExpression()
{
CastExpression ce = ParseUtilVBNet.ParseExpression<CastExpression>("DirectCast(o, List(of T))");
Assert.AreEqual("List", ce.CastTo.Type);
Assert.AreEqual("T", ce.CastTo.GenericTypes[0].Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.AreEqual(CastType.Cast, ce.CastType);
}
[Test]
public void VBNetSimpleTryCastExpression()
{
CastExpression ce = ParseUtilVBNet.ParseExpression<CastExpression>("TryCast(o, MyObject)");
Assert.AreEqual("MyObject", ce.CastTo.Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.AreEqual(CastType.TryCast, ce.CastType);
}
[Test]
public void VBNetGenericTryCastExpression()
{
CastExpression ce = ParseUtilVBNet.ParseExpression<CastExpression>("TryCast(o, List(of T))");
Assert.AreEqual("List", ce.CastTo.Type);
Assert.AreEqual("T", ce.CastTo.GenericTypes[0].Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
Assert.AreEqual(CastType.TryCast, ce.CastType);
}
[Test]

4
src/Libraries/NRefactory/Test/Parser/Expressions/ConditionalExpressionTests.cs

@ -1,4 +1,4 @@ @@ -1,4 +1,4 @@
// <file>
// <file>
// <copyright see="prj:///doc/copyright.txt">2002-2005 AlphaSierraPapa</copyright>
// <license see="prj:///doc/license.txt">GNU General Public License</license>
// <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.Tests.AST
// (as is b?) ERROR (conflict with nullables, SD2-419)
ConditionalExpression ce = ParseUtilCSharp.ParseExpression<ConditionalExpression>("a is b ? a() : a.B");
Assert.IsTrue(ce.Condition is BinaryOperatorExpression);
Assert.IsTrue(ce.Condition is TypeOfIsExpression);
Assert.IsTrue(ce.TrueExpression is InvocationExpression);
Assert.IsTrue(ce.FalseExpression is FieldReferenceExpression);
}

28
src/Libraries/NRefactory/Test/Parser/Expressions/TypeOfIsExpressionTests.cs

@ -1,4 +1,4 @@ @@ -1,4 +1,4 @@
// <file>
// <file>
// <copyright see="prj:///doc/copyright.txt">2002-2005 AlphaSierraPapa</copyright>
// <license see="prj:///doc/license.txt">GNU General Public License</license>
// <owner name="Mike Krüger" email="mike@icsharpcode.net"/>
@ -17,15 +17,33 @@ namespace ICSharpCode.NRefactory.Tests.AST @@ -17,15 +17,33 @@ namespace ICSharpCode.NRefactory.Tests.AST
public class TypeOfIsExpressionTests
{
#region C#
// No C# representation
[Test]
public void GenericArrayIsExpression()
{
TypeOfIsExpression ce = ParseUtilCSharp.ParseExpression<TypeOfIsExpression>("o is List<string>[]");
Assert.AreEqual("List", ce.TypeReference.Type);
Assert.AreEqual("string", ce.TypeReference.GenericTypes[0].Type);
Assert.AreEqual(new int[] { 0 }, ce.TypeReference.RankSpecifier);
Assert.IsTrue(ce.Expression is IdentifierExpression);
}
#endregion
#region VB.NET
[Test]
public void VBNetTypeOfIsExpressionTest()
public void VBNetSimpleTypeOfIsExpression()
{
TypeOfIsExpression ce = ParseUtilVBNet.ParseExpression<TypeOfIsExpression>("TypeOf o Is MyObject");
Assert.AreEqual("MyObject", ce.TypeReference.Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
}
[Test]
public void VBNetGenericTypeOfIsExpression()
{
TypeOfExpression toe = ParseUtilVBNet.ParseExpression<TypeOfExpression>("TypeOf time is System.DateTime");
// TODO : Extend test.
TypeOfIsExpression ce = ParseUtilVBNet.ParseExpression<TypeOfIsExpression>("TypeOf o Is List(of T)");
Assert.AreEqual("List", ce.TypeReference.Type);
Assert.AreEqual("T", ce.TypeReference.GenericTypes[0].Type);
Assert.IsTrue(ce.Expression is IdentifierExpression);
}
#endregion
}

6
src/Main/Base/Project/Src/Dom/ClassFinder.cs

@ -57,6 +57,12 @@ namespace ICSharpCode.SharpDevelop.Dom @@ -57,6 +57,12 @@ namespace ICSharpCode.SharpDevelop.Dom
this.projectContent = cu.ProjectContent;
}
// currently callingMember is not required
public ClassFinder(IClass callingClass, IMember callingMember, int caretLine, int caretColumn)
: this(callingClass, caretLine, caretColumn)
{
}
void Init(string fileName)
{
ParseInformation parseInfo = ParserService.GetParseInformation(fileName);

18
src/Main/Base/Project/Src/Dom/NRefactoryResolver/TypeVisitor.cs

@ -40,7 +40,6 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver @@ -40,7 +40,6 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
public override object Visit(BinaryOperatorExpression binaryOperatorExpression, object data)
{
switch (binaryOperatorExpression.Op) {
case BinaryOperatorType.AsCast:
case BinaryOperatorType.NullCoalescing:
return binaryOperatorExpression.Right.AcceptVisitor(this, data);
case BinaryOperatorType.DivideInteger:
@ -51,7 +50,6 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver @@ -51,7 +50,6 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
case BinaryOperatorType.InEquality:
case BinaryOperatorType.ReferenceEquality:
case BinaryOperatorType.ReferenceInequality:
case BinaryOperatorType.TypeCheck:
case BinaryOperatorType.LogicalAnd:
case BinaryOperatorType.LogicalOr:
case BinaryOperatorType.LessThan:
@ -327,28 +325,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver @@ -327,28 +325,12 @@ namespace ICSharpCode.SharpDevelop.Dom.NRefactoryResolver
// TODO: Little bug: unary operator MAY change the return type,
// but that is only a minor issue
switch (unaryOperatorExpression.Op) {
case UnaryOperatorType.Not:
break;
case UnaryOperatorType.BitNot:
break;
case UnaryOperatorType.Minus:
break;
case UnaryOperatorType.Plus:
break;
case UnaryOperatorType.Increment:
case UnaryOperatorType.PostIncrement:
break;
case UnaryOperatorType.Decrement:
case UnaryOperatorType.PostDecrement:
break;
case UnaryOperatorType.Star: // dereference
//--expressionType.PointerNestingLevel;
break;
case UnaryOperatorType.BitWiseAnd: // get reference
//++expressionType.PointerNestingLevel;
break;
case UnaryOperatorType.None:
break;
}
return expressionType;
}

Loading…
Cancel
Save