public VSharpTypeResolveContext GetTypeResolveContext(ICompilation compilation, Location loc)
{
var rctx = new VSharpTypeResolveContext(compilation.MainAssembly);
rctx = rctx.WithUsingScope(GetUsingScope(loc).ResolveScope(compilation));
var curDef = GetInnermostTypeDefinition(loc);
if (curDef != null)
{
var resolvedDef = curDef.Resolve(rctx).GetDefinition();
if (resolvedDef == null)
{
return(rctx);
}
rctx = rctx.WithCurrentTypeDefinition(resolvedDef);
var curMember = resolvedDef.Members.FirstOrDefault(m => m.Region.FileName == FileName && m.Region.Begin <= loc && loc < m.BodyRegion.End);
if (curMember != null)
{
rctx = rctx.WithCurrentMember(curMember);
}
}
return(rctx);
}
IType ITypeReference.Resolve(ITypeResolveContext context)
{
// Strictly speaking, we might have to resolve the type in a nested compilation, similar
// to what we're doing with ConstantExpression.
// However, in almost all cases this will work correctly - if the resulting type is only available in the
// nested compilation and not in this, we wouldn't be able to map it anyways.
var ctx = context as VSharpTypeResolveContext;
if (ctx == null)
{
ctx = new VSharpTypeResolveContext(context.CurrentAssembly ?? context.Compilation.MainAssembly, null, context.CurrentTypeDefinition, context.CurrentMember);
}
return(ResolveType(new ResolveContext(ctx, CompilerContext.report)));
// A potential issue might be this scenario:
// Assembly 1:
// class A { public class Nested {} }
// Assembly 2: (references asm 1)
// class B : A {}
// Assembly 3: (references asm 1 and 2)
// class C { public B.Nested Field; }
// Assembly 4: (references asm 1 and 3, but not 2):
// uses C.Field;
// Here we would not be able to resolve 'B.Nested' in the compilation of assembly 4, as type B is missing there.
}
VSharpTypeResolveContext MapToNestedCompilation(VSharpTypeResolveContext context, ICompilation nestedCompilation)
{
var nestedContext = new VSharpTypeResolveContext(nestedCompilation.MainAssembly);
if (context.CurrentUsingScope != null)
{
nestedContext = nestedContext.WithUsingScope(context.CurrentUsingScope.UnresolvedUsingScope.ResolveScope(nestedCompilation));
}
if (context.CurrentTypeDefinition != null)
{
nestedContext = nestedContext.WithCurrentTypeDefinition(nestedCompilation.Import(context.CurrentTypeDefinition));
}
return nestedContext;
}
