public override void LookupSymbolsInSingleBinder(LookupResult result, LookupConstraints constraints)
{
Debug.Assert(result.IsClear);
if (IsSubmission)
{
this.LookupMembersInternal(result, constraints.WithQualifier(_container));
return;
}
var imports = GetImports(constraints.BasesBeingResolved);
// first lookup members of the namespace
if ((constraints.Options & LookupOptions.NamespaceAliasesOnly) == 0 && _container != null)
{
this.LookupMembersInternal(result, constraints.WithQualifier(_container));
if (result.IsMultiViable)
{
// symbols cannot conflict with using alias names
if (constraints.MetadataName == constraints.Name && imports.IsUsingAlias(constraints.Name, constraints.OriginalBinder.IsSemanticModelBinder))
{
LanguageDiagnosticInfo diagInfo = new LanguageDiagnosticInfo(InternalErrorCode.ERR_ConflictAliasAndMember, constraints.Name, _container);
var error = new ExtendedErrorTypeSymbol((NamespaceOrTypeSymbol)null, constraints.Name, constraints.MetadataName, diagInfo, unreported: true);
result.SetFrom(LookupResult.Good(error)); // force lookup to be done w/ error symbol as result
}
return;
}
}
// next try using aliases or symbols in imported namespaces
imports.LookupSymbol(result, constraints);
}
/// <summary>
/// Add a diagnostic to the bag.
/// </summary>
/// <param name="diagnostics"></param>
/// <param name="code"></param>
/// <param name="args"></param>
/// <returns></returns>
public static LanguageDiagnosticInfo Add(this DiagnosticBag diagnostics, ErrorCode code, Location location, params object[] args)
{
var info = new LanguageDiagnosticInfo(code, args);
var diag = new LanguageDiagnostic(info, location);
diagnostics.Add(diag);
return(info);
}
/// <summary>
/// Derive error info from a type symbol.
/// </summary>
internal bool DeriveUseSiteDiagnosticFromType(ref DiagnosticInfo result, TypeSymbol type)
{
DiagnosticInfo info = type.GetUseSiteDiagnostic();
if (info != null)
{
if (info.HasErrorCode(InternalErrorCode.ERR_BogusType))
{
switch (this.Kind.Switch())
{
case LanguageSymbolKind.Name:
case LanguageSymbolKind.Operation:
case LanguageSymbolKind.Property:
info = new LanguageDiagnosticInfo(InternalErrorCode.ERR_BindToBogus, this);
break;
}
}
}
return(MergeUseSiteDiagnostics(ref result, info));
}
private static ExtendedErrorTypeSymbol CyclicInheritanceError(RetargetingNamedTypeSymbol type, TypeSymbol declaredBase)
{
var info = new LanguageDiagnosticInfo(InternalErrorCode.ERR_ImportedCircularBase, declaredBase, type);
return(new ExtendedErrorTypeSymbol(declaredBase, LookupResultKind.NotReferencable, info, true));
}
internal ErrorTypeSymbol CreateMultipleForwardingErrorTypeSymbol(ref MetadataTypeName emittedName, ModuleSymbol forwardingModule, AssemblySymbol destination1, AssemblySymbol destination2)
{
var diagnosticInfo = new LanguageDiagnosticInfo(InternalErrorCode.ERR_TypeForwardedToMultipleAssemblies, forwardingModule, this, emittedName.FullName, destination1, destination2);
return(new MissingMetadataTypeSymbol.TopLevelWithCustomErrorInfo(forwardingModule, ref emittedName, diagnosticInfo));
}
internal ErrorTypeSymbol CreateCycleInTypeForwarderErrorTypeSymbol(ref MetadataTypeName emittedName)
{
DiagnosticInfo diagnosticInfo = new LanguageDiagnosticInfo(InternalErrorCode.ERR_CycleInTypeForwarder, emittedName.FullName, this.Name);
return(new MissingMetadataTypeSymbol.TopLevelWithCustomErrorInfo(this.Modules[0], ref emittedName, diagnosticInfo));
}
public override bool GetUnificationUseSiteDiagnostic(ref DiagnosticInfo result, TypeSymbol dependentType)
{
AssertReferencesInitialized();
var ownerModule = this;
var ownerAssembly = ownerModule.ContainingAssembly;
var dependentAssembly = dependentType.ContainingAssembly;
if (ownerAssembly == dependentAssembly)
{
return(false);
}
// TODO (tomat): we should report an error/warning for all unified references, not just the first one.
foreach (var unifiedAssembly in GetUnifiedAssemblies())
{
if (!ReferenceEquals(unifiedAssembly.TargetAssembly, dependentAssembly))
{
continue;
}
var referenceId = unifiedAssembly.OriginalReference;
var definitionId = dependentAssembly.Identity;
var involvedAssemblies = ImmutableArray.Create <Symbol>(ownerAssembly, dependentAssembly);
DiagnosticInfo info;
if (definitionId.Version > referenceId.Version)
{
// unified with a definition whose version is higher than the reference
ErrorCode warning = (definitionId.Version.Major == referenceId.Version.Major && definitionId.Version.Minor == referenceId.Version.Minor) ?
InternalErrorCode.WRN_UnifyReferenceBldRev : InternalErrorCode.WRN_UnifyReferenceMajMin;
// warning: Assuming assembly reference '{0}' used by '{1}' matches identity '{2}' of '{3}', you may need to supply runtime policy.
info = new LanguageDiagnosticInfo(
warning,
new object[]
{
referenceId.GetDisplayName(),
ownerAssembly.Name, // TODO (tomat): should rather be MetadataReference.Display for the corresponding reference
definitionId.GetDisplayName(),
dependentAssembly.Name
},
involvedAssemblies,
ImmutableArray <Location> .Empty);
}
else
{
// unified with a definition whose version is lower than the reference
// error: Assembly '{0}' with identity '{1}' uses '{2}' which has a higher version than referenced assembly '{3}' with identity '{4}'
info = new LanguageDiagnosticInfo(
InternalErrorCode.ERR_AssemblyMatchBadVersion,
new object[]
{
ownerAssembly.Name, // TODO (tomat): should rather be MetadataReference.Display for the corresponding reference
ownerAssembly.Identity.GetDisplayName(),
referenceId.GetDisplayName(),
dependentAssembly.Name, // TODO (tomat): should rather be MetadataReference.Display for the corresponding reference
definitionId.GetDisplayName()
},
involvedAssemblies,
ImmutableArray <Location> .Empty);
}
if (MergeUseSiteDiagnostics(ref result, info))
{
return(true);
}
}
return(false);
}
