DefinitionExtractionContext.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="DefinitionExtractionContext.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Helper for definition extraction, used to optimise symbo, recognition</summary>
//-----------------------------------------------------------------------
using Csla.Serialization;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Csla.Generators.CSharp.AutoSerialization.Discovery
{
 
  internal class DefinitionExtractionContext
  {
 
    private readonly GeneratorSyntaxContext _context;
    private readonly INamedTypeSymbol _autoSerializableAttributeSymbol;
    private readonly INamedTypeSymbol _autoSerializedAttributeSymbol;
    private readonly INamedTypeSymbol _autoNonSerializedAttributeSymbol;
    private readonly INamedTypeSymbol _mobileObjectInterfaceSymbol;
 
    public DefinitionExtractionContext(GeneratorSyntaxContext context)
    {
      _context = context;
      _autoSerializableAttributeSymbol = context.SemanticModel.Compilation.GetTypeByMetadataName(typeof(AutoSerializableAttribute).FullName);
      _autoSerializedAttributeSymbol = context.SemanticModel.Compilation.GetTypeByMetadataName(typeof(AutoSerializedAttribute).FullName);
      _autoNonSerializedAttributeSymbol = context.SemanticModel.Compilation.GetTypeByMetadataName(typeof(AutoNonSerializedAttribute).FullName);
      _mobileObjectInterfaceSymbol = context.SemanticModel.Compilation.GetTypeByMetadataName(typeof(Csla.Serialization.Mobile.IMobileObject).FullName);
    }
 
    public GeneratorSyntaxContext Context => _context;
 
    public string GetTypeNamespace(TypeDeclarationSyntax typeDeclarationSyntax)
    {
      INamedTypeSymbol typeSymbol;
 
      typeSymbol = _context.SemanticModel.GetDeclaredSymbol(typeDeclarationSyntax) as INamedTypeSymbol;
      if (typeSymbol is null || typeSymbol.ContainingNamespace is null) return string.Empty;
      return typeSymbol.ContainingNamespace.ToString();
    }
 
    public string GetTypeNamespace(TypeSyntax typeSyntax)
    {
      INamedTypeSymbol typeSymbol;
 
      typeSymbol = _context.SemanticModel.GetSymbolInfo(typeSyntax).Symbol as INamedTypeSymbol;
      if (typeSymbol is null || typeSymbol.ContainingNamespace is null) return string.Empty;
      return typeSymbol.ContainingNamespace.ToString();
    }
 
    public bool IsTypeAutoSerializable(TypeDeclarationSyntax typeDeclarationSyntax)
    {
      INamedTypeSymbol typeSymbol;
 
      typeSymbol = _context.SemanticModel.GetDeclaredSymbol(typeDeclarationSyntax) as INamedTypeSymbol;
      return IsTypeDecoratedBy(typeSymbol, _autoSerializableAttributeSymbol);
    }
 
    public bool IsTypeAutoSerializable(TypeSyntax typeSyntax)
    {
      INamedTypeSymbol typeSymbol;
 
      typeSymbol = _context.SemanticModel.GetSymbolInfo(typeSyntax).Symbol as INamedTypeSymbol;
      if (typeSymbol is null) return false;
      return IsTypeDecoratedBy(typeSymbol, _autoSerializableAttributeSymbol);
    }
 
    public bool DoesTypeImplementIMobileObject(TypeSyntax typeSyntax)
    {
      INamedTypeSymbol typeSymbol;
 
      typeSymbol = _context.SemanticModel.GetSymbolInfo(typeSyntax).Symbol as INamedTypeSymbol;
      if (typeSymbol is null) return false;
 
      foreach (ITypeSymbol interfaceSymbol in typeSymbol.AllInterfaces)
      {
        if (IsMatchingTypeSymbol(interfaceSymbol as INamedTypeSymbol, _mobileObjectInterfaceSymbol))
        {
          return true;
        }
      }
 
      return false;
    }
 
    public bool IsPropertyDecoratedWithAutoSerialized(PropertyDeclarationSyntax propertyDeclaration)
    {
      return IsPropertyDecoratedWith(propertyDeclaration, _autoSerializedAttributeSymbol);
    }
 
    public bool IsPropertyDecoratedWithAutoNonSerialized(PropertyDeclarationSyntax propertyDeclaration)
    {
      return IsPropertyDecoratedWith(propertyDeclaration, _autoNonSerializedAttributeSymbol);
    }
 
    public bool IsFieldDecoratedWithAutoSerialized(FieldDeclarationSyntax fieldDeclaration)
    {
      return IsFieldDecoratedWith(fieldDeclaration, _autoSerializedAttributeSymbol);
    }
 
    public bool IsFieldDecoratedWithAutoNonSerialized(FieldDeclarationSyntax fieldDeclaration)
    {
      return IsFieldDecoratedWith(fieldDeclaration, _autoNonSerializedAttributeSymbol);
    }
 
    #region Private Helper Methods
 
    private bool IsTypeDecoratedBy(INamedTypeSymbol typeSymbol, INamedTypeSymbol desiredAttributeSymbol)
    {
      return typeSymbol.GetAttributes().Any(
        attr => IsMatchingTypeSymbol(attr.AttributeClass, desiredAttributeSymbol));
    }
 
    private bool IsPropertyDecoratedWith(PropertyDeclarationSyntax propertyDeclaration, INamedTypeSymbol desiredAttributeSymbol)
    {
      INamedTypeSymbol appliedAttributeSymbol;
 
      foreach (AttributeSyntax attributeSyntax in propertyDeclaration.AttributeLists.SelectMany(al => al.Attributes))
      {
        appliedAttributeSymbol = _context.SemanticModel.GetTypeInfo(attributeSyntax).Type as INamedTypeSymbol;
        if (IsMatchingTypeSymbol(appliedAttributeSymbol, desiredAttributeSymbol))
        {
          return true;
        }
      }
      return false;
    }
 
    private bool IsFieldDecoratedWith(FieldDeclarationSyntax fieldDeclaration, INamedTypeSymbol desiredAttributeSymbol)
    {
      INamedTypeSymbol appliedAttributeSymbol;
 
      foreach (AttributeSyntax attributeSyntax in fieldDeclaration.AttributeLists.SelectMany(al => al.Attributes))
      {
        appliedAttributeSymbol = _context.SemanticModel.GetTypeInfo(attributeSyntax).Type as INamedTypeSymbol;
        if (IsMatchingTypeSymbol(appliedAttributeSymbol, desiredAttributeSymbol))
        {
          return true;
        }
      }
      return false;
    }
 
    private bool IsMatchingTypeSymbol(INamedTypeSymbol appliedAttributeSymbol, INamedTypeSymbol desiredAttributeSymbol)
    {
      return SymbolEqualityComparer.Default.Equals(appliedAttributeSymbol, desiredAttributeSymbol);
    }
 
    #endregion
 
  }
}