source: branches/RemoveBackwardsCompatibility/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory.CSharp-5.5.0/Refactoring/BaseRefactoringContext.cs

// 
// BaseRefactoringContext.cs
//  
// Author:
//       Mike Krüger <mkrueger@xamarin.com>
// 
// Copyright (c) 2012 Xamarin <http://xamarin.com>
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

using System;
using System.Linq;
using System.Threading;
using ICSharpCode.NRefactory.CSharp.Resolver;
using ICSharpCode.NRefactory.CSharp.TypeSystem;
using ICSharpCode.NRefactory.Semantics;
using ICSharpCode.NRefactory.TypeSystem;
using ICSharpCode.NRefactory.TypeSystem.Implementation;
using ICSharpCode.NRefactory.Editor;
using System.ComponentModel.Design;
using ICSharpCode.NRefactory.CSharp.Analysis;
using ICSharpCode.NRefactory.Utils;
using System.Collections.Generic;
using ICSharpCode.NRefactory.Analysis;

namespace ICSharpCode.NRefactory.CSharp.Refactoring
{
  public abstract class BaseRefactoringContext : IServiceProvider
  {
    readonly CSharpAstResolver resolver;
    readonly CancellationToken cancellationToken;
    
    public virtual bool Supports(Version version)
    {
      return true;
    }

    /// <summary>
    /// Gets the default namespace which should be defined in this file.
    /// </summary>
    public abstract string DefaultNamespace {
      get;
    }

    /// <summary>
    /// Gets a value indicating if 'var' keyword should be used or explicit types.
    /// </summary>
    public virtual bool UseExplicitTypes {
      get;
      set;
    }
    
    public CancellationToken CancellationToken {
      get { return cancellationToken; }
    }
    
    public virtual AstNode RootNode {
      get {
        return resolver.RootNode;
      }
    }

    public CSharpAstResolver Resolver {
      get {
        return resolver;
      }
    }

    public virtual CSharpUnresolvedFile UnresolvedFile {
      get {
        return resolver.UnresolvedFile;
      }
    }

    public ICompilation Compilation {
      get { return resolver.Compilation; }
    }

    /// <summary>
    /// Gets the type graph for the current compilation.
    /// </summary>
    public virtual TypeGraph TypeGraph {
      get { return new TypeGraph(Compilation.Assemblies); }
    }
    
    public BaseRefactoringContext (ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver resolver, System.Threading.CancellationToken cancellationToken)
    {
      this.resolver = resolver;
      this.cancellationToken = cancellationToken;
      this.referenceFinder = new LocalReferenceFinder(resolver);
    }


    #region Resolving
    public ResolveResult Resolve (AstNode node)
    {
      return resolver.Resolve (node, cancellationToken);
    }
    
    public CSharpResolver GetResolverStateBefore(AstNode node)
    {
      return resolver.GetResolverStateBefore (node, cancellationToken);
    }
    
    public CSharpResolver GetResolverStateAfter(AstNode node)
    {
      return resolver.GetResolverStateAfter (node, cancellationToken);
    }

    public IType ResolveType (AstType type)
    {
      return resolver.Resolve (type, cancellationToken).Type;
    }
    
    public IType GetExpectedType (Expression expression)
    {
      return resolver.GetExpectedType(expression, cancellationToken);
    }
    
    public Conversion GetConversion (Expression expression)
    {
      return resolver.GetConversion(expression, cancellationToken);
    }
    
    public TypeSystemAstBuilder CreateTypeSystemAstBuilder(AstNode node)
    {
      var csResolver = resolver.GetResolverStateBefore(node);
      return new TypeSystemAstBuilder(csResolver);
    }
    #endregion

    #region Code Analyzation
    /// <summary>
    /// Creates a new definite assignment analysis object with a given root statement.
    /// </summary>
    /// <returns>
    /// The definite assignment analysis object.
    /// </returns>
    /// <param name='root'>
    /// The root statement.
    /// </param>
    public DefiniteAssignmentAnalysis CreateDefiniteAssignmentAnalysis (Statement root)
    {
      return new DefiniteAssignmentAnalysis (root, resolver, CancellationToken);
    }

    /// <summary>
    /// Creates a new reachability analysis object with a given statement.
    /// </summary>
    /// <param name="statement">
    /// The statement to start the analysis.
    /// </param>
    /// <param name="recursiveDetectorVisitor">
    /// TODO.
    /// </param>
    /// <returns>
    /// The reachability analysis object.
    /// </returns>
    public ReachabilityAnalysis CreateReachabilityAnalysis (Statement statement, ReachabilityAnalysis.RecursiveDetectorVisitor recursiveDetectorVisitor = null)
    {
      return ReachabilityAnalysis.Create (statement, resolver, recursiveDetectorVisitor, CancellationToken);
    }

    /// <summary>
    /// Parses a composite format string.
    /// </summary>
    /// <returns>
    /// The format string parsing result.
    /// </returns>
    public virtual FormatStringParseResult ParseFormatString(string source)
    {
      return new CompositeFormatStringParser().Parse(source);
    }

    LocalReferenceFinder referenceFinder;

    public IList<ReferenceResult> FindReferences(AstNode rootNode, IVariable variable)
    {
      return referenceFinder.FindReferences(rootNode, variable);
    }

    #endregion


    #region Naming
    public virtual string GetNameProposal (string name, TextLocation loc, bool camelCase = true)
    {
      string baseName = (camelCase ? char.ToLower (name [0]) : char.ToUpper (name [0])) + name.Substring (1);

      var type = RootNode.GetNodeAt<TypeDeclaration>(loc);
      if (type == null)
        return baseName;

      int number = -1;
      string proposedName;
      do {
        proposedName = AppendNumberToName (baseName, number++);
      } while (type.Members.Select (m => m.GetChildByRole (Roles.Identifier)).Any (n => n.Name == proposedName));
      return proposedName;
    }
    
    public virtual string GetLocalNameProposal (string name, TextLocation loc, bool camelCase = true)
    {
      string baseName = (camelCase ? char.ToLower (name [0]) : char.ToUpper (name [0])) + name.Substring (1);
      var node = RootNode.GetNodeAt(loc);
      if (node == null)
        return baseName;
      
      var context = GetResolverStateBefore (node);
      int number = -1;
      string proposedName;
      do {
        proposedName = AppendNumberToName (baseName, number++);
      } while (!(context.ResolveSimpleName (proposedName, EmptyList<IType>.Instance) is UnknownIdentifierResolveResult));
      return proposedName;
    }

    static string AppendNumberToName (string baseName, int number)
    {
      return baseName + (number > 0 ? (number + 1).ToString () : "");
    }
    #endregion

    #region Text stuff
    public virtual TextEditorOptions TextEditorOptions {
      get {
        return TextEditorOptions.Default;
      }
    }

    public virtual bool IsSomethingSelected {
      get {
        return SelectionStart != TextLocation.Empty;
      }
    }

    public virtual string SelectedText {
      get { return string.Empty; }
    }

    public virtual TextLocation SelectionStart {
      get {
        return TextLocation.Empty;
      }
    }

    public virtual TextLocation SelectionEnd {
      get {
        return TextLocation.Empty;
      }
    }

    public abstract int GetOffset (TextLocation location);

    public abstract IDocumentLine GetLineByOffset (int offset);

    public int GetOffset (int line, int col)
    {
      return GetOffset (new TextLocation (line, col));
    }

    public abstract TextLocation GetLocation (int offset);

    public abstract string GetText (int offset, int length);

    public abstract string GetText (ISegment segment);
    #endregion


    /// <summary>
    /// Translates the english input string to the context language.
    /// </summary>
    /// <returns>
    /// The translated string.
    /// </returns>
    public virtual string TranslateString(string str)
    {
      return str;
    }

    #region IServiceProvider implementation
    IServiceContainer services = new ServiceContainer();
    
    /// <summary>
    /// Gets a service container used to associate services with this context.
    /// </summary>
    public IServiceContainer Services {
      get { return services; }
      protected set { services = value; }
    }
    
    /// <summary>
    /// Retrieves a service from the refactoring context.
    /// If the service is not found in the <see cref="Services"/> container.
    /// </summary>
    public object GetService(Type serviceType)
    {
      return services.GetService(serviceType);
    }
    #endregion
  }
  
}