.NET Decompiler with support for PDB generation, ReadyToRun, Metadata (&more) - cross-platform!
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

319 lines
8.8 KiB

//
// 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
}
}