public IObjectContext CreateForSerialization(IMemberContext sourceMember, object source, IAdviceRequester adviceRequester)
{
return Factories
.Select(f => f.CreateForSerialization(sourceMember, source, adviceRequester))
.Where(d => d != null)
.FirstOrDefault();
}
public Type GetActualType(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
{
return Converters
.Select(c => c.GetActualType(source, target, adviceRequester))
.Where(t => t != null)
.FirstOrDefault();
}
public bool Serialize(IMemberContext source, XObject target, IAdviceRequester adviceRequester)
{
if (source == null)
throw new ArgumentNullException("source");
if (target.NodeType != XmlNodeType.Element)
throw new ArgumentException("Parameter must be an XML element.", "target");
var elem = (XElement)target;
IObjectContext sourceObject = source.GetValue();
if (sourceObject == null || sourceObject.GetObject() == null)
{
if (_isNullableStrategy.IsNullable(source, elem, adviceRequester))
{
elem.Add(Constants.XsiNilAttribute);
return true;
}
return false;
}
List<IMapping<IMemberContext, XObject>> mappings = _mapper.MapForSerialization(source, elem, adviceRequester)
.ToList();
if (mappings == null)
throw new ArgumentException("Unable to map source '" + source + "' and target '" + target + "'.");
SerializeRecursively(elem, mappings, adviceRequester);
return true;
}
public IDeserializer Select(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
{
return Selectors
.Select(s => s.Select(source, target, adviceRequester))
.Where(d => d != null)
.FirstOrDefault();
}
public ISerializer Select(IMemberContext source, XObject target, IAdviceRequester adviceRequester)
{
if (target.NodeType != XmlNodeType.Element)
return null;
return _serializer;
}
// TODO: Replace IMemberContext with MemberCore
public EmitContext (IMemberContext rc, ILGenerator ig, TypeSpec return_type)
{
this.MemberContext = rc;
this.ig = ig;
this.return_type = return_type;
}
public void Deserialize(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
{
if (source == null)
return;
if (source.NodeType != XmlNodeType.Element)
throw new ArgumentException("Parameter must be an XML element.", "source");
if (_log.IsDebugEnabled)
_log.Debug("Deserializing " + source.ToFriendlyName() + " into " + target + ".");
var elem = (XElement)source;
Type targetType = _typeConverter.GetActualType(source, target, adviceRequester);
if (targetType == null)
throw new ArgumentException("Unable to get target type for target '" + target + "'.");
IObjectContext targetObject = _objectContextFactory.CreateForDeserialization(target, targetType, adviceRequester);
if (targetObject == null)
throw new ArgumentException("Unable to create target object for target '" + target + "'.");
target.SetValue(targetObject);
List<IMapping<XObject, IMemberContext>> mappings = _mapper.MapForDeserialization(elem, target, adviceRequester)
.ToList();
if (mappings == null)
throw new ArgumentException("Unable to map source '" + source + "' and target '" + target + "'.");
DeserializeRecursively(mappings, adviceRequester);
target.CommitChanges();
}
public IObjectContext CreateForDeserialization(IMemberContext targetMember, Type targetType, IAdviceRequester adviceRequester)
{
return Factories
.Select(f => f.CreateForDeserialization(targetMember, targetType, adviceRequester))
.Where(d => d != null)
.FirstOrDefault();
}
private static IMapping<IMemberContext, XObject> CreateMappingForSerialization(IMemberContext member, XElement target)
{
var targetTypeAndName = GetTargetTypeAndName(member);
XObject xobj;
bool addTargetToParent = true;
switch (targetTypeAndName.Key)
{
case XmlNodeType.Element:
if (!member.ContractType.IsSubTypeOf<IXmlSerializable>() && member.ContractType.IsCollectionType() && HasXmlElementAttribute(member) || HasXmlTextAttribute(member))
{
xobj = target;
addTargetToParent = false;
}
else
xobj = new XElement(targetTypeAndName.Value);
break;
case XmlNodeType.Attribute:
xobj = new XAttribute(targetTypeAndName.Value, string.Empty);
break;
default:
throw new ArgumentOutOfRangeException("Mapped to an unknown node type: " + targetTypeAndName.Key + ".");
}
return new Mapping<IMemberContext, XObject>(member, xobj, addTargetToParent);
}
public IEnumerable<IMapping<XObject, IMemberContext>> MapForDeserialization(XElement source, IMemberContext target, IAdviceRequester adviceRequester)
{
if (source == null)
throw new ArgumentNullException("source");
if (target == null)
throw new ArgumentNullException("target");
var targetObject = target.GetValue();
foreach (var member in targetObject.Members.Where(m => !m.Attributes.OfType<XmlIgnoreAttribute>().Any()))
{
var sourceType = GetSourceTypeAndPotentialNames(member);
switch (sourceType.Key)
{
case XmlNodeType.Element:
foreach (var mapping in GetMappingsFromElement(sourceType.Value, source, targetObject, member, adviceRequester))
yield return mapping;
break;
case XmlNodeType.Attribute:
yield return GetMappingFromAttribute(sourceType.Value, source, member);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
protected virtual IDeserializer Select(XObject source, IMemberContext target, Type type, IAdviceRequester adviceRequester)
{
var typeCode = Type.GetTypeCode(type);
switch (typeCode)
{
case TypeCode.Empty:
case TypeCode.DBNull:
return null;
case TypeCode.Object:
if (target.ContractType == typeof(TimeSpan))
break;
if (target.ContractType == typeof(string))
break;
if (target.ContractType.IsNullable())
break;
return null;
}
if (source == null)
return GetDeserializer(type);
if (source.NodeType == XmlNodeType.Element && !((XElement)source).HasElements)
return GetDeserializer(type);
if (source.NodeType == XmlNodeType.Attribute)
return GetDeserializer(type);
return null;
}
public override IDeserializer Select(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
{
var contractTypeFromAttr = GetContractTypeFromAttributes(source, target);
if (contractTypeFromAttr == null)
return null;
return Select(source, target, contractTypeFromAttr, adviceRequester);
}
private static Type GetActualTypeFromXmlElementAttribute(XElement source, IMemberContext target)
{
if (source == null)
return null;
return GetTypeFromXmlElementAttributeWithMatchingName(source, target)
?? GetTypeFromXmlElementAttributeWithoutName(target);
}
public IObjectContext CreateForSerialization(IMemberContext sourceMember, object source, IAdviceRequester adviceRequester)
{
if (source == null)
return null;
ObjectContextInfo contextInfo = GetContextInfo(source.GetType(), adviceRequester);
return contextInfo.CreateFor(source);
}
public bool ResolveType(IMemberContext mc, TypeSpec defaultType)
{
if (TypeExpression != null)
this.Type = TypeExpression.ResolveAsType (mc);
else
this.Type = defaultType;
return this.Type != null;
}
public MultipleMatchesAdviceRequestedEventArgs(XElement source, IObjectContext targetOwner, IMemberContext target, IEnumerable<XObject> matches, XObject selectedMatch)
: base(CommonAdviceTypes.MultipleMatches)
{
Source = source;
TargetOwner = targetOwner;
Target = target;
Matches = (matches ?? Enumerable.Empty<XObject>()).ToList();
SelectedMatch = selectedMatch;
}
public override TypeExpr ResolveAsType (IMemberContext ec)
{
var type = ec.Module.PredefinedTypes.Nullable.Resolve ();
if (type == null)
return null;
TypeArguments args = new TypeArguments (underlying);
GenericTypeExpr ctype = new GenericTypeExpr (type, args, loc);
return ctype.ResolveAsType (ec);
}
protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec)
{
var type = ec.Module.PredefinedTypes.Nullable.Resolve (loc);
if (type == null)
return null;
TypeArguments args = new TypeArguments (underlying);
GenericTypeExpr ctype = new GenericTypeExpr (type, args, loc);
return ctype.ResolveAsTypeTerminal (ec, false);
}
private static Type GetTypeFromXmlAttributeAttributeWithoutName(IMemberContext target)
{
return target.Attributes
.OfType<XmlAttributeAttribute>()
.Where(a => string.IsNullOrWhiteSpace(a.AttributeName))
.Where(a => a.Type != null)
.Where(a => target.ContractType.IsAssignableFrom(a.Type))
.Select(a => a.Type)
.FirstOrDefault();
}
public IObjectContext CreateForDeserialization(IMemberContext targetMember, Type targetType, IAdviceRequester adviceRequester)
{
ObjectContextInfo contextInfo = GetContextInfo(targetType, adviceRequester);
object target = _instantiator.Create(targetType, adviceRequester);
if (target == null)
throw new ArgumentException("Unable to create instance of '" + targetType + "' for member '" + targetMember + "'.");
return contextInfo.CreateFor(target);
}
private static Type GetTypeFromXmlArrayItemAttributeWithMatchingName(XElement source, IMemberContext target)
{
return target.Attributes
.OfType<XmlArrayItemAttribute>()
.Where(a => !string.IsNullOrWhiteSpace(a.ElementName))
.Where(a => a.ElementName == source.Name)
.Where(a => a.Type != null)
.Where(a => target.ContractType.IsAssignableFrom(a.Type))
.Select(a => a.Type)
.FirstOrDefault();
}
public bool Serialize(IMemberContext source, XObject target, IAdviceRequester adviceRequester)
{
if (source == null)
throw new ArgumentNullException("source");
var sourceObject = source.GetValue().GetObject();
if (target.NodeType != XmlNodeType.Element)
throw new ArgumentException("Parameter must be an XML element.", "source");
var elem = (XElement)target;
var xmlSerializable = (IXmlSerializable)sourceObject;
var memoryStream = new MemoryStream();
var xmlWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
xmlWriter.WriteStartElement(elem.Name.LocalName);
xmlWriter.WriteAttributeString("xmlns", "xsi", null, Constants.XmlSchemaInstanceNamespaceAttribute.Value);
xmlWriter.WriteAttributeString("xmlns", "xsd", null, Constants.XmlSchemaNamespaceAttribute.Value);
xmlSerializable.WriteXml(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.Flush();
memoryStream.Position = 0;
var tempTarget = XElement.Load(memoryStream);
if (tempTarget.HasElements)
foreach (var element in tempTarget.Elements())
elem.Add(element);
else
elem.SetValue(tempTarget.Value);
foreach (var attribute in tempTarget.Attributes())
{
if (attribute.Name == Constants.XmlSchemaNamespaceAttribute.Name || attribute.Name == Constants.XmlSchemaInstanceNamespaceAttribute.Name)
continue;
elem.Add(attribute);
}
foreach (var childElem in elem.Elements())
{
var xmlnsXsiAttr = childElem.Attribute(Constants.XmlSchemaInstanceNamespaceAttribute.Name);
if (xmlnsXsiAttr != null)
xmlnsXsiAttr.Remove();
var xmlnsXsdAttr = childElem.Attribute(Constants.XmlSchemaNamespaceAttribute.Name);
if (xmlnsXsdAttr != null)
xmlnsXsdAttr.Remove();
}
return true;
}
private static Type GetContractTypeFromXmlElementAttributes(XObject source, IMemberContext target)
{
var elem = source as XElement;
if (elem == null)
return null;
return (from attr in target.Attributes.OfType<XmlElementAttribute>()
where attr.Type != null
where attr.ElementName == elem.Name
select attr.Type).FirstOrDefault();
}
protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec)
{
if (TypeManager.generic_nullable_type == null) {
TypeManager.generic_nullable_type = TypeManager.CoreLookupType (ec.Compiler,
"System", "Nullable", 1, MemberKind.Struct, true);
}
TypeArguments args = new TypeArguments (underlying);
GenericTypeExpr ctype = new GenericTypeExpr (TypeManager.generic_nullable_type, args, loc);
return ctype.ResolveAsTypeTerminal (ec, false);
}
public BlockContext (IMemberContext mc, ExplicitBlock block, TypeSpec returnType)
: base (mc)
{
if (returnType == null)
throw new ArgumentNullException ("returnType");
this.return_type = returnType;
// TODO: check for null value
CurrentBlock = block;
}
public IDeserializer Select(XObject source, IMemberContext target, IAdviceRequester adviceRequester)
{
Type actualType = _typeConverter.GetActualType(source, target, adviceRequester);
if (actualType == null)
return null;
if (_log.IsDebugEnabled)
_log.Debug("Selected collection deserialization for source '" + source.ToFriendlyName() + "' and target '" + target + "'.");
return _deserializer;
}
public void AddAttributes (Attributes attrs, IMemberContext context)
{
if (attrs == null)
return;
if (attributes == null)
attributes = attrs;
else
throw new NotImplementedException ();
attributes.AttachTo (this, context);
}
public EmitContext (IMemberContext rc, ILGenerator ig, TypeSpec return_type)
{
this.member_context = rc;
this.ig = ig;
this.return_type = return_type;
if (rc.Module.Compiler.Settings.Checked)
flags |= Options.CheckedScope;
#if STATIC
ig.__CleverExceptionBlockAssistance ();
#endif
}
private static IEnumerable<XName> GetElementNamesFromXmlArrayItemAttributes(IMemberContext target)
{
var arrayItemNames = target.Attributes
.OfType<XmlArrayItemAttribute>()
.Select(a => (XName)a.ElementName)
.Where(n => n != null)
.ToList();
if (!arrayItemNames.Any())
return null;
return arrayItemNames;
}
public IEnumerable<IMapping<XObject, IMemberContext>> MapForDeserialization(XElement source, IMemberContext target, IAdviceRequester adviceRequester)
{
var targetObject = target.GetValue();
if (targetObject == null)
throw new ArgumentException("Target should have had it value set to a collection at this point.", "target");
var elementNames = GetElementNames(target);
return source.Elements()
.Where(e => elementNames.Contains(e.Name, CaseInsensitiveXNameComparer.Instance))
.Select(elem => new Mapping<XObject, IMemberContext>(elem, targetObject.Members.Single()))
.ToList();
}
// <summary>
// Resolve is used in method definitions
// </summary>
public virtual TypeSpec Resolve(IMemberContext rc, int index)
{
if (parameter_type != null)
{
return(parameter_type);
}
if (attributes != null)
{
attributes.AttachTo(this, rc);
}
parameter_type = texpr.ResolveAsType(rc);
if (parameter_type == null)
{
return(null);
}
this.idx = index;
if ((modFlags & Parameter.Modifier.RefOutMask) != 0 && parameter_type.IsSpecialRuntimeType)
{
rc.Module.Compiler.Report.Error(1601, Location, "Method or delegate parameter cannot be of type `{0}'",
GetSignatureForError());
return(null);
}
TypeManager.CheckTypeVariance(parameter_type,
(modFlags & Parameter.Modifier.RefOutMask) != 0 ? Variance.None : Variance.Contravariant,
rc);
if (parameter_type.IsStatic)
{
rc.Module.Compiler.Report.Error(721, Location, "`{0}': static types cannot be used as parameters",
texpr.GetSignatureForError());
return(parameter_type);
}
if ((modFlags & Modifier.This) != 0 && (parameter_type.IsPointer || parameter_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic))
{
rc.Module.Compiler.Report.Error(1103, Location, "The extension method cannot be of type `{0}'",
TypeManager.CSharpName(parameter_type));
}
return(parameter_type);
}
public override TypeSpec Resolve(IMemberContext ec, int index)
{
if (base.Resolve(ec, index) == null)
{
return(null);
}
var ac = parameter_type as ArrayContainer;
if (ac == null || ac.Rank != 1)
{
ec.Module.Compiler.Report.Error(225, Location, "The params parameter must be a single dimensional array");
return(null);
}
return(parameter_type);
}
public override TypeSpec ResolveAsType(IMemberContext ec)
{
eclass = ExprClass.Type;
var otype = ec.Module.PredefinedTypes.Nullable.Resolve();
if (otype == null)
{
return(null);
}
TypeArguments args = new TypeArguments(new TypeExpression(underlying, loc));
GenericTypeExpr ctype = new GenericTypeExpr(otype, args, loc);
type = ctype.ResolveAsType(ec);
return(type);
}
public static void Create(IMemberContext context, ParametersBlock block, ParametersCompiled parameters, TypeContainer host, TypeSpec returnType, Location loc)
{
if (returnType != null && returnType.Kind != MemberKind.Void &&
returnType != host.Module.PredefinedTypes.Task.TypeSpec &&
!returnType.IsGenericTask)
{
host.Compiler.Report.Error(1983, loc, "The return type of an async method must be void, Task, or Task<T>");
}
for (int i = 0; i < parameters.Count; i++)
{
Parameter p = parameters[i];
Parameter.Modifier mod = p.ModFlags;
if ((mod & Parameter.Modifier.ISBYREF) != 0)
{
host.Compiler.Report.Error(1988, p.Location,
"Async methods cannot have ref or out parameters");
return;
}
// TODO:
if (p is ArglistParameter)
{
host.Compiler.Report.Error(1636, p.Location,
"__arglist is not allowed in parameter list of iterators");
return;
}
// TODO:
if (parameters.Types[i].IsPointer)
{
host.Compiler.Report.Error(1637, p.Location,
"Iterators cannot have unsafe parameters or yield types");
return;
}
}
if (!block.IsAsync)
{
host.Compiler.Report.Warning(1998, 1, loc,
"Async block lacks `await' operator and will run synchronously");
}
block.WrapIntoAsyncTask(context, host, returnType);
}
public ResolveContext (IMemberContext mc)
{
if (mc == null)
throw new ArgumentNullException ();
MemberContext = mc;
//
// The default setting comes from the command line option
//
if (mc.Module.Compiler.Settings.Checked)
flags |= Options.CheckedScope;
//
// The constant check state is always set to true
//
flags |= Options.ConstantCheckState;
}
public ResolveContext(IMemberContext mc)
{
if (mc == null)
{
throw new ArgumentNullException();
}
MemberContext = mc;
//
// The default setting comes from the command line option
//
if (mc.Module.Compiler.Settings.Checked)
{
flags |= Options.CheckedScope;
}
//
// The constant check state is always set to true
//
flags |= Options.ConstantCheckState;
//
// File type set from member context module sourcefile.
//
var memberCore = mc as MemberCore;
if (memberCore != null && memberCore.Location.SourceFile != null)
{
fileType = memberCore.Location.SourceFile.FileType;
}
else if (mc.Module != null && mc.Module.Location.SourceFile != null)
{
fileType = mc.Module.Location.SourceFile.FileType;
if (mc.Module.Location.SourceFile.PsExtended)
{
flags |= Options.PsExtended;
}
}
else
{
fileType = SourceFileType.CSharp;
}
}
public static TypeInfo GetTypeInfo(TypeSpec type, IMemberContext context)
{
if (!type.IsStruct)
{
return(simple_type);
}
TypeInfo info;
Dictionary <TypeSpec, TypeInfo> type_hash;
if (type.BuiltinType > 0)
{
// Don't cache built-in types, they are null in most cases except for
// corlib compilation when we need to distinguish between declaration
// and referencing
type_hash = null;
}
else
{
type_hash = context.Module.TypeInfoCache;
if (type_hash.TryGetValue(type, out info))
{
return(info);
}
}
var struct_info = StructInfo.GetStructInfo(type, context);
if (struct_info != null)
{
info = new TypeInfo(struct_info, 0);
}
else
{
info = simple_type;
}
if (type_hash != null)
{
type_hash.Add(type, info);
}
return(info);
}
//
// Extension methods look up for dotted namespace names
//
public IList <MethodSpec> LookupExtensionMethod(IMemberContext invocationContext, TypeSpec extensionType, string name, int arity, out Namespace scope)
{
//
// Inspect parent namespaces in namespace expression
//
scope = this;
do
{
var candidates = scope.LookupExtensionMethod(invocationContext, extensionType, name, arity);
if (candidates != null)
{
return(candidates);
}
scope = scope.Parent;
} while (scope != null);
return(null);
}
//
// System.Linq.Expressions.ParameterExpression type
//
public static TypeExpr ResolveParameterExpressionType(IMemberContext ec, Location location)
{
if (parameter_expr_tree_type != null)
{
return(parameter_expr_tree_type);
}
Type p_type = TypeManager.parameter_expression_type;
if (p_type == null)
{
p_type = TypeManager.CoreLookupType(ec.Compiler, "System.Linq.Expressions", "ParameterExpression", Kind.Class, true);
TypeManager.parameter_expression_type = p_type;
}
parameter_expr_tree_type = new TypeExpression(p_type, location).
ResolveAsTypeTerminal(ec, false);
return(parameter_expr_tree_type);
}
public override FullNamedExpression Resolve(IMemberContext rc, bool local)
{
if (resolved != null || value == null)
{
return(resolved);
}
if (local)
{
return(null);
}
resolved = value.GetTypeExpression().ResolveAsTypeOrNamespace(rc);
if (resolved == null)
{
value = null;
return(null);
}
return(resolved);
}
public void Error_NamespaceDoesNotExist(IMemberContext ctx, string name, int arity, Location loc)
{
var retval = LookupType(ctx, name, arity, LookupMode.IgnoreAccessibility, loc);
if (retval != null)
{
ctx.Module.Compiler.Report.SymbolRelatedToPreviousError(retval.Type);
ErrorIsInaccesible(ctx, retval.GetSignatureForError(), loc);
return;
}
retval = LookupType(ctx, name, -System.Math.Max(1, arity), LookupMode.Probing, loc);
if (retval != null)
{
Error_TypeArgumentsCannotBeUsed(ctx, retval.Type, arity, loc);
return;
}
Namespace ns;
if (arity > 0 && namespaces.TryGetValue(name, out ns))
{
ns.Error_TypeArgumentsCannotBeUsed(ctx, null, arity, loc);
return;
}
if (this is GlobalRootNamespace)
{
ctx.Module.Compiler.Report.Error(400, loc,
"The type or namespace name `{0}' could not be found in the global namespace (are you missing an assembly reference?)",
name);
}
else
{
ctx.Module.Compiler.Report.Error(234, loc,
"The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
name, GetSignatureForError());
}
}
///
/// Looks for extension method in this namespace
///
public List <MethodSpec> LookupExtensionMethod(IMemberContext invocationContext, TypeSpec extensionType, string name, int arity)
{
if (types == null)
{
return(null);
}
List <MethodSpec> found = null;
// TODO: Add per namespace flag when at least 1 type has extension
foreach (var tgroup in types.Values)
{
foreach (var ts in tgroup)
{
if ((ts.Modifiers & Modifiers.METHOD_EXTENSION) == 0)
{
continue;
}
var res = ts.MemberCache.FindExtensionMethods(invocationContext, extensionType, name, arity);
if (res == null)
{
continue;
}
if (found == null)
{
found = res;
}
else
{
found.AddRange(res);
}
}
}
return(found);
}
public MemberSpec FindElement(IMemberContext mc, string name, Location loc)
{
// TODO: cache it
for (int i = 0; i < elements.Count; ++i)
{
var ename = elements [i];
if (ename == null || ename != name)
{
continue;
}
var member_name = GetElementPropertyName(i);
var ms = MemberCache.FindMember(tuple, MemberFilter.Field(member_name, null), BindingRestriction.DeclaredOnly | BindingRestriction.InstanceOnly);
if (ms == null)
{
mc.Module.Compiler.Report.Error(8128, loc, "Member `{0}' was not found on type '{1}'", member_name, tuple.GetSignatureForError());
return(null);
}
return(ms);
}
return(null);
}
public Namespace Resolve(IMemberContext rc)
{
if (resolved != null)
{
return(resolved);
}
FullNamedExpression fne = name.GetTypeExpression().ResolveAsTypeOrNamespace(rc);
if (fne == null)
{
return(null);
}
resolved = fne as Namespace;
if (resolved == null)
{
rc.Module.Compiler.Report.SymbolRelatedToPreviousError(fne.Type);
rc.Module.Compiler.Report.Error(138, Location,
"`{0}' is a type not a namespace. A using namespace directive can only be applied to namespaces",
GetSignatureForError());
}
return(resolved);
}
public static void Create(IMemberContext context, ParametersBlock block, ParametersCompiled parameters, TypeContainer host, TypeSpec returnType, Location loc)
{
for (int i = 0; i < parameters.Count; i++)
{
Parameter p = parameters[i];
Parameter.Modifier mod = p.ModFlags;
if ((mod & Parameter.Modifier.ISBYREF) != 0)
{
host.Compiler.Report.Error(1988, p.Location,
"Async methods cannot have ref or out parameters");
return;
}
if (p is ArglistParameter)
{
host.Compiler.Report.Error(4006, p.Location,
"__arglist is not allowed in parameter list of async methods");
return;
}
if (parameters.Types[i].IsPointer)
{
host.Compiler.Report.Error(4005, p.Location,
"Async methods cannot have unsafe parameters");
return;
}
}
if (!block.IsAsync)
{
host.Compiler.Report.Warning(1998, 1, loc,
"Async block lacks `await' operator and will run synchronously");
}
block.WrapIntoAsyncTask(context, host, returnType);
}
public bool IsConditionallyExcluded(IMemberContext ctx)
{
if ((Kind & (MemberKind.Class | MemberKind.Method)) == 0)
{
return(false);
}
var conditions = MemberDefinition.ConditionalConditions();
if (conditions == null)
{
return(false);
}
var m = ctx.CurrentMemberDefinition;
CompilationSourceFile unit = null;
while (m != null && unit == null)
{
unit = m as CompilationSourceFile;
m = m.Parent;
}
if (unit != null)
{
foreach (var condition in conditions)
{
if (unit.IsConditionalDefined(condition))
{
return(false);
}
}
}
return(true);
}
public AsyncTaskStorey(ParametersBlock block, IMemberContext context, AsyncInitializer initializer, TypeSpec type)
: base(block, initializer.Host, context.CurrentMemberDefinition as MemberBase, context.CurrentTypeParameters, "async", MemberKind.Struct)
{
return_type = type;
awaiter_fields = new Dictionary <TypeSpec, List <Field> > ();
}
public ResolveContext(IMemberContext mc, Options options)
: this(mc)
{
flags |= options;
}
public override TypeSpec ResolveAsType(IMemberContext ec)
{
eclass = ExprClass.Type;
type = ec.Module.Compiler.BuiltinTypes.Dynamic;
return(type);
}
public override void EncodeAttributeValue(IMemberContext rc, AttributeEncoder enc, TypeSpec targetType)
{
throw new NotSupportedException();
}
//
// Is this member accessible from invocation context
//
public bool IsAccessible(IMemberContext ctx)
{
var ma = Modifiers & Modifiers.AccessibilityMask;
if (ma == Modifiers.PUBLIC)
{
return(true);
}
var parentType = /* this as TypeSpec ?? */ DeclaringType;
var ctype = ctx.CurrentType;
if (ma == Modifiers.PRIVATE)
{
if (ctype == null || parentType == null)
{
return(false);
}
//
// It's only accessible to the current class or children
//
if (parentType.MemberDefinition == ctype.MemberDefinition)
{
return(true);
}
return(TypeManager.IsNestedChildOf(ctype, parentType.MemberDefinition));
}
if ((ma & Modifiers.INTERNAL) != 0)
{
bool b;
var assembly = ctype == null ? ctx.Module.DeclaringAssembly : ctype.MemberDefinition.DeclaringAssembly;
if (parentType == null)
{
b = ((ITypeDefinition)MemberDefinition).IsInternalAsPublic(assembly);
}
else
{
b = DeclaringType.MemberDefinition.IsInternalAsPublic(assembly);
}
if (b || ma == Modifiers.INTERNAL)
{
return(b);
}
}
//
// Checks whether `ctype' is a subclass or nested child of `parentType'.
//
while (ctype != null)
{
if (TypeManager.IsFamilyAccessible(ctype, parentType))
{
return(true);
}
// Handle nested types.
ctype = ctype.DeclaringType; // TODO: Untested ???
}
return(false);
}
public override TypeSpec ResolveAsType(IMemberContext ec, bool allowUnboundTypeArguments)
{
eclass = ExprClass.Type;
type = ec.Module.Compiler.BuiltinTypes.Dynamic;
return(type);
}
public override TypeSpec ResolveAsType(IMemberContext ec)
{
type = ec.CurrentType;
eclass = ExprClass.Type;
return(type);
}
public override TypeSpec Resolve(IMemberContext ec, int index)
{
return(parameter_type);
}
//
// System.Linq.Expressions.ParameterExpression type
//
public static TypeExpr ResolveParameterExpressionType(IMemberContext ec, Location location)
{
TypeSpec p_type = ec.Module.PredefinedTypes.ParameterExpression.Resolve();
return(new TypeExpression(p_type, location));
}
public void Resolve(IMemberContext context)
{
type = Type.ResolveAsType(context);
}
public FieldInitializerContext(IMemberContext mc, ResolveContext constructorContext)
: base(mc, Options.FieldInitializerScope | Options.ConstructorScope)
{
this.ctor_block = constructorContext.CurrentBlock.Explicit;
}
public AddMeetingNotAttendeeCommandHandler(IMemberContext memberContext, IMeetingRepository meetingRepository)
{
_memberContext = memberContext;
_meetingRepository = meetingRepository;
}
public override FullNamedExpression ResolveAsTypeOrNamespace(IMemberContext mc)
{
return(this);
}
public TypeExpr LookupType(IMemberContext ctx, string name, int arity, LookupMode mode, Location loc)
{
if (types == null)
{
return(null);
}
TypeExpr te;
if (arity == 0 && cached_types.TryGetValue(name, out te))
{
return(te);
}
IList <TypeSpec> found;
if (!types.TryGetValue(name, out found))
{
return(null);
}
TypeSpec best = null;
foreach (var ts in found)
{
if (ts.Arity == arity)
{
if (best == null)
{
if ((ts.Modifiers & Modifiers.INTERNAL) != 0 && !ts.MemberDefinition.IsInternalAsPublic(ctx.Module.DeclaringAssembly) && mode != LookupMode.IgnoreAccessibility)
{
continue;
}
best = ts;
continue;
}
if (best.MemberDefinition.IsImported && ts.MemberDefinition.IsImported)
{
if (mode == LookupMode.Normal)
{
ctx.Module.Compiler.Report.SymbolRelatedToPreviousError(best);
ctx.Module.Compiler.Report.SymbolRelatedToPreviousError(ts);
ctx.Module.Compiler.Report.Error(433, loc, "The imported type `{0}' is defined multiple times", ts.GetSignatureForError());
}
break;
}
if (best.MemberDefinition.IsImported)
{
best = ts;
}
if ((best.Modifiers & Modifiers.INTERNAL) != 0 && !best.MemberDefinition.IsInternalAsPublic(ctx.Module.DeclaringAssembly))
{
continue;
}
if (mode != LookupMode.Normal)
{
continue;
}
if (ts.MemberDefinition.IsImported)
{
ctx.Module.Compiler.Report.SymbolRelatedToPreviousError(ts);
}
ctx.Module.Compiler.Report.Warning(436, 2, loc,
"The type `{0}' conflicts with the imported type of same name'. Ignoring the imported type definition",
best.GetSignatureForError());
}
//
// Lookup for the best candidate with the closest arity match
//
if (arity < 0)
{
if (best == null)
{
best = ts;
}
else if (System.Math.Abs(ts.Arity + arity) < System.Math.Abs(best.Arity + arity))
{
best = ts;
}
}
}
if (best == null)
{
return(null);
}
te = new TypeExpression(best, Location.Null);
// TODO MemberCache: Cache more
if (arity == 0 && mode == LookupMode.Normal)
{
cached_types.Add(name, te);
}
return(te);
}