pimhwang
/
CppSharp
mirror of https://github.com/mono/CppSharp.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Don't check the unsupported operator= for symbols 

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>
pull/1517/head
Dimitar Dobrev 5 years ago
parent
b4cece4601
commit
6f276debf6
5 changed files with 184 additions and 151 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      src/Generator.Tests/Passes/TestPasses.cs
  2. 11
      src/Generator/Driver.cs
  3. 8
      src/Generator/Passes/CheckDuplicatedNamesPass.cs
  4. 144
      src/Generator/Passes/CheckOperatorsOverloads.cs
  5. 156
      src/Generator/Passes/ValidateOperatorsPass.cs

16
src/Generator.Tests/Passes/TestPasses.cs
Unescape View File

@ -186,21 +186,17 @@ namespace CppSharp.Generator.Tests.Passes
Assert.IsNotNull(@class); Assert.IsNotNull(@class);
var overloads = @class.Methods.Where(m => m.Name == "Method"); var overloads = @class.Methods.Where(m => m.Name == "Method");
var constMethod = overloads var constMethod = overloads
.Where(m => m.IsConst && m.Parameters.Count == 0) .FirstOrDefault(m => m.IsConst && m.Parameters.Count == 0);
.FirstOrDefault();
var nonConstMethod = overloads var nonConstMethod = overloads
.Where(m => !m.IsConst && m.Parameters.Count == 0) .FirstOrDefault(m => !m.IsConst && m.Parameters.Count == 0);
.FirstOrDefault();
Assert.IsNotNull(constMethod); Assert.IsNotNull(constMethod);
Assert.IsNotNull(nonConstMethod); Assert.IsNotNull(nonConstMethod);
Assert.IsTrue(constMethod.GenerationKind == GenerationKind.None); Assert.IsTrue(constMethod.GenerationKind == GenerationKind.None);
Assert.IsTrue(nonConstMethod.GenerationKind == GenerationKind.Generate); Assert.IsTrue(nonConstMethod.GenerationKind == GenerationKind.Generate);
var constMethodWithParam = overloads var constMethodWithParam = overloads
.Where(m => m.IsConst && m.Parameters.Count == 1) .FirstOrDefault(m => m.IsConst && m.Parameters.Count == 1);
.FirstOrDefault();
var nonConstMethodWithParam = overloads var nonConstMethodWithParam = overloads
.Where(m => !m.IsConst && m.Parameters.Count == 1) .FirstOrDefault(m => !m.IsConst && m.Parameters.Count == 1);
.FirstOrDefault();
Assert.IsNotNull(constMethodWithParam); Assert.IsNotNull(constMethodWithParam);
Assert.IsNotNull(nonConstMethodWithParam); Assert.IsNotNull(nonConstMethodWithParam);
Assert.IsTrue(constMethodWithParam.GenerationKind == GenerationKind.None); Assert.IsTrue(constMethodWithParam.GenerationKind == GenerationKind.None);
@ -226,7 +222,7 @@ namespace CppSharp.Generator.Tests.Passes
[Test] [Test]
public void TestAbstractOperator() public void TestAbstractOperator()
{ {
passBuilder.AddPass(new CheckOperatorsOverloadsPass()); passBuilder.AddPass(new ValidateOperatorsPass());
passBuilder.RunPasses(pass => pass.VisitASTContext(AstContext)); passBuilder.RunPasses(pass => pass.VisitASTContext(AstContext));
var @class = AstContext.FindDecl<Class>("ClassWithAbstractOperator").First(); var @class = AstContext.FindDecl<Class>("ClassWithAbstractOperator").First();
@ -246,7 +242,7 @@ namespace CppSharp.Generator.Tests.Passes
Assert.IsNotNull(@public); Assert.IsNotNull(@public);
Assert.AreEqual(AccessSpecifier.Public, @public.Access); */ Assert.AreEqual(AccessSpecifier.Public, @public.Access); */
var @protected = @class.Fields.Where(f => f.Name == "Protected").FirstOrDefault(); var @protected = @class.Fields.Find(f => f.Name == "Protected");
Assert.IsNotNull(@protected); Assert.IsNotNull(@protected);
Assert.AreEqual(AccessSpecifier.Protected, @protected.Access); Assert.AreEqual(AccessSpecifier.Protected, @protected.Access);
} }

11
src/Generator/Driver.cs
Unescape View File

@ -223,17 +223,18 @@ namespace CppSharp
TranslationUnitPasses.AddPass(new CheckIgnoredDeclsPass()); TranslationUnitPasses.AddPass(new CheckIgnoredDeclsPass());
} }
if (Options.IsCLIGenerator || Options.IsCSharpGenerator)
{
TranslationUnitPasses.AddPass(new MoveFunctionToClassPass());
TranslationUnitPasses.AddPass(new ValidateOperatorsPass());
}
library.SetupPasses(this); library.SetupPasses(this);
TranslationUnitPasses.AddPass(new FindSymbolsPass()); TranslationUnitPasses.AddPass(new FindSymbolsPass());
TranslationUnitPasses.AddPass(new CheckMacroPass()); TranslationUnitPasses.AddPass(new CheckMacroPass());
TranslationUnitPasses.AddPass(new CheckStaticClass()); TranslationUnitPasses.AddPass(new CheckStaticClass());
if (Options.IsCLIGenerator || Options.IsCSharpGenerator)
{
TranslationUnitPasses.AddPass(new MoveFunctionToClassPass());
}
TranslationUnitPasses.AddPass(new CheckAmbiguousFunctions()); TranslationUnitPasses.AddPass(new CheckAmbiguousFunctions());
TranslationUnitPasses.AddPass(new ConstructorToConversionOperatorPass()); TranslationUnitPasses.AddPass(new ConstructorToConversionOperatorPass());
TranslationUnitPasses.AddPass(new MarshalPrimitivePointersAsRefTypePass()); TranslationUnitPasses.AddPass(new MarshalPrimitivePointersAsRefTypePass());

8
src/Generator/Passes/CheckDuplicatedNamesPass.cs
Unescape View File

@ -189,13 +189,7 @@ namespace CppSharp.Passes
public class CheckDuplicatedNamesPass : TranslationUnitPass public class CheckDuplicatedNamesPass : TranslationUnitPass
{ {
private readonly IDictionary<string, DeclarationName> names; private readonly IDictionary<string, DeclarationName> names = new Dictionary<string, DeclarationName>();
public CheckDuplicatedNamesPass()
{
ClearVisitedDeclarations = false;
names = new Dictionary<string, DeclarationName>();
}
public override bool VisitASTContext(ASTContext context) public override bool VisitASTContext(ASTContext context)
{ {

144
src/Generator/Passes/CheckOperatorsOverloads.cs
Unescape View File

@ -10,17 +10,24 @@ namespace CppSharp.Passes
/// </summary> /// </summary>
public class CheckOperatorsOverloadsPass : TranslationUnitPass public class CheckOperatorsOverloadsPass : TranslationUnitPass
{ {
public CheckOperatorsOverloadsPass() public CheckOperatorsOverloadsPass() =>
{ VisitOptions.VisitClassBases =
ClearVisitedDeclarations = false; VisitOptions.VisitClassFields =
} VisitOptions.VisitEventParameters =
VisitOptions.VisitFunctionParameters =
VisitOptions.VisitFunctionReturnType =
VisitOptions.VisitClassMethods =
VisitOptions.VisitNamespaceEnums =
VisitOptions.VisitNamespaceEvents =
VisitOptions.VisitNamespaceTemplates =
VisitOptions.VisitNamespaceTypedefs =
VisitOptions.VisitNamespaceVariables =
VisitOptions.VisitPropertyAccessors =
VisitOptions.VisitTemplateArguments = false;
public override bool VisitClassDecl(Class @class) public override bool VisitClassDecl(Class @class)
{ {
if (@class.CompleteDeclaration != null) if (!base.VisitClassDecl(@class))
return VisitClassDecl(@class.CompleteDeclaration as Class);
if (!VisitDeclarationContext(@class))
return false; return false;
// Check for C++ operators that cannot be represented in .NET. // Check for C++ operators that cannot be represented in .NET.
@ -49,14 +56,6 @@ namespace CppSharp.Passes
{ {
foreach (var @operator in @class.Operators.Where(o => o.IsGenerated)) foreach (var @operator in @class.Operators.Where(o => o.IsGenerated))
{ {
if (!IsValidOperatorOverload(@operator) || @operator.IsPure)
{
Diagnostics.Debug("Invalid operator overload {0}::{1}",
@class.OriginalName, @operator.OperatorKind);
@operator.ExplicitlyIgnore();
continue;
}
if (@operator.IsNonMemberOperator) if (@operator.IsNonMemberOperator)
continue; continue;
@ -184,118 +183,5 @@ namespace CppSharp.Passes
index = 0; index = 0;
return CXXOperatorKind.None; return CXXOperatorKind.None;
} }
private bool IsValidOperatorOverload(Method @operator)
{
// These follow the order described in MSDN (Overloadable Operators).
switch (@operator.OperatorKind)
{
// These unary operators can be overloaded
case CXXOperatorKind.Plus:
case CXXOperatorKind.Minus:
case CXXOperatorKind.Exclaim:
case CXXOperatorKind.Tilde:
// These binary operators can be overloaded
case CXXOperatorKind.Slash:
case CXXOperatorKind.Percent:
case CXXOperatorKind.Amp:
case CXXOperatorKind.Pipe:
case CXXOperatorKind.Caret:
// The array indexing operator can be overloaded
case CXXOperatorKind.Subscript:
// The conversion operators can be overloaded
case CXXOperatorKind.Conversion:
case CXXOperatorKind.ExplicitConversion:
return true;
// The comparison operators can be overloaded if their return type is bool
case CXXOperatorKind.EqualEqual:
case CXXOperatorKind.ExclaimEqual:
case CXXOperatorKind.Less:
case CXXOperatorKind.Greater:
case CXXOperatorKind.LessEqual:
case CXXOperatorKind.GreaterEqual:
return @operator.ReturnType.Type.IsPrimitiveType(PrimitiveType.Bool);
// Only prefix operators can be overloaded
case CXXOperatorKind.PlusPlus:
case CXXOperatorKind.MinusMinus:
Class @class;
var returnType = @operator.OriginalReturnType.Type.Desugar();
returnType = (returnType.GetFinalPointee() ?? returnType).Desugar();
return returnType.TryGetClass(out @class) &&
@class.GetNonIgnoredRootBase() ==
((Class) @operator.Namespace).GetNonIgnoredRootBase() &&
@operator.Parameters.Count == 0;
// Bitwise shift operators can only be overloaded if the second parameter is int
case CXXOperatorKind.LessLess:
case CXXOperatorKind.GreaterGreater:
{
Parameter parameter = @operator.Parameters.Last();
Type type = parameter.Type.Desugar();
switch (Options.GeneratorKind)
{
case GeneratorKind.CLI:
return type.IsPrimitiveType(PrimitiveType.Int);
case GeneratorKind.CSharp:
Types.TypeMap typeMap;
if (Context.TypeMaps.FindTypeMap(type, out typeMap))
{
var mappedTo = typeMap.CSharpSignatureType(
new TypePrinterContext
{
Parameter = parameter,
Type = type
});
var cilType = mappedTo as CILType;
if (cilType?.Type == typeof(int))
return true;
}
break;
}
return false;
}
// No parameters means the dereference operator - cannot be overloaded
case CXXOperatorKind.Star:
return @operator.Parameters.Count > 0;
// Assignment operators cannot be overloaded
case CXXOperatorKind.PlusEqual:
case CXXOperatorKind.MinusEqual:
case CXXOperatorKind.StarEqual:
case CXXOperatorKind.SlashEqual:
case CXXOperatorKind.PercentEqual:
case CXXOperatorKind.AmpEqual:
case CXXOperatorKind.PipeEqual:
case CXXOperatorKind.CaretEqual:
case CXXOperatorKind.LessLessEqual:
case CXXOperatorKind.GreaterGreaterEqual:
// The conditional logical operators cannot be overloaded
case CXXOperatorKind.AmpAmp:
case CXXOperatorKind.PipePipe:
// These operators cannot be overloaded.
case CXXOperatorKind.Equal:
case CXXOperatorKind.Comma:
case CXXOperatorKind.ArrowStar:
case CXXOperatorKind.Arrow:
case CXXOperatorKind.Call:
case CXXOperatorKind.Conditional:
case CXXOperatorKind.Coawait:
case CXXOperatorKind.New:
case CXXOperatorKind.Delete:
case CXXOperatorKind.Array_New:
case CXXOperatorKind.Array_Delete:
default:
return false;
}
}
} }
} }

156
src/Generator/Passes/ValidateOperatorsPass.cs
Unescape View File

@ -0,0 +1,156 @@
using System.Linq;
using CppSharp.AST;
using CppSharp.AST.Extensions;
using CppSharp.Generators;
namespace CppSharp.Passes
{
/// <summary>
/// Validates operators for C# (if they can be overloaded).
/// </summary>
public class ValidateOperatorsPass : TranslationUnitPass
{
public ValidateOperatorsPass() =>
VisitOptions.VisitClassBases =
VisitOptions.VisitClassFields =
VisitOptions.VisitEventParameters =
VisitOptions.VisitFunctionParameters =
VisitOptions.VisitFunctionReturnType =
VisitOptions.VisitNamespaceEnums =
VisitOptions.VisitNamespaceEvents =
VisitOptions.VisitNamespaceTemplates =
VisitOptions.VisitNamespaceTypedefs =
VisitOptions.VisitNamespaceVariables =
VisitOptions.VisitPropertyAccessors =
VisitOptions.VisitTemplateArguments = false;
public override bool VisitMethodDecl(Method method)
{
if (!base.VisitMethodDecl(method) ||
!method.IsOperator || !method.IsGenerated)
return false;
if (!IsValidOperatorOverload(method) || method.IsPure)
{
Diagnostics.Debug("Invalid operator overload {0}::{1}",
method.Namespace.Name, method.OperatorKind);
method.ExplicitlyIgnore();
}
return true;
}
private bool IsValidOperatorOverload(Method @operator)
{
// These follow the order described in MSDN (Overloadable Operators).
switch (@operator.OperatorKind)
{
// These unary operators can be overloaded
case CXXOperatorKind.Plus:
case CXXOperatorKind.Minus:
case CXXOperatorKind.Exclaim:
case CXXOperatorKind.Tilde:
// These binary operators can be overloaded
case CXXOperatorKind.Slash:
case CXXOperatorKind.Percent:
case CXXOperatorKind.Amp:
case CXXOperatorKind.Pipe:
case CXXOperatorKind.Caret:
// The array indexing operator can be overloaded
case CXXOperatorKind.Subscript:
// The conversion operators can be overloaded
case CXXOperatorKind.Conversion:
case CXXOperatorKind.ExplicitConversion:
return true;
// The comparison operators can be overloaded if their return type is bool
case CXXOperatorKind.EqualEqual:
case CXXOperatorKind.ExclaimEqual:
case CXXOperatorKind.Less:
case CXXOperatorKind.Greater:
case CXXOperatorKind.LessEqual:
case CXXOperatorKind.GreaterEqual:
return @operator.ReturnType.Type.IsPrimitiveType(PrimitiveType.Bool);
// Only prefix operators can be overloaded
case CXXOperatorKind.PlusPlus:
case CXXOperatorKind.MinusMinus:
Class @class;
var returnType = @operator.OriginalReturnType.Type.Desugar();
returnType = (returnType.GetFinalPointee() ?? returnType).Desugar();
return returnType.TryGetClass(out @class) &&
@class.GetNonIgnoredRootBase() ==
((Class) @operator.Namespace).GetNonIgnoredRootBase() &&
@operator.Parameters.Count == 0;
// Bitwise shift operators can only be overloaded if the second parameter is int
case CXXOperatorKind.LessLess:
case CXXOperatorKind.GreaterGreater:
{
Parameter parameter = @operator.Parameters.Last();
Type type = parameter.Type.Desugar();
switch (Options.GeneratorKind)
{
case GeneratorKind.CLI:
return type.IsPrimitiveType(PrimitiveType.Int);
case GeneratorKind.CSharp:
Types.TypeMap typeMap;
if (Context.TypeMaps.FindTypeMap(type, out typeMap))
{
var mappedTo = typeMap.CSharpSignatureType(
new TypePrinterContext
{
Parameter = parameter,
Type = type
});
var cilType = mappedTo as CILType;
if (cilType?.Type == typeof(int))
return true;
}
break;
}
return false;
}
// No parameters means the dereference operator - cannot be overloaded
case CXXOperatorKind.Star:
return @operator.Parameters.Count > 0;
// Assignment operators cannot be overloaded
case CXXOperatorKind.PlusEqual:
case CXXOperatorKind.MinusEqual:
case CXXOperatorKind.StarEqual:
case CXXOperatorKind.SlashEqual:
case CXXOperatorKind.PercentEqual:
case CXXOperatorKind.AmpEqual:
case CXXOperatorKind.PipeEqual:
case CXXOperatorKind.CaretEqual:
case CXXOperatorKind.LessLessEqual:
case CXXOperatorKind.GreaterGreaterEqual:
// The conditional logical operators cannot be overloaded
case CXXOperatorKind.AmpAmp:
case CXXOperatorKind.PipePipe:
// These operators cannot be overloaded.
case CXXOperatorKind.Equal:
case CXXOperatorKind.Comma:
case CXXOperatorKind.ArrowStar:
case CXXOperatorKind.Arrow:
case CXXOperatorKind.Call:
case CXXOperatorKind.Conditional:
case CXXOperatorKind.Coawait:
case CXXOperatorKind.New:
case CXXOperatorKind.Delete:
case CXXOperatorKind.Array_New:
case CXXOperatorKind.Array_Delete:
default:
return false;
}
}
}
}
Write Preview
Loading…
Cancel
Save