static IUnresolvedField LanguageItemToIField(IUnresolvedTypeDefinition type, LanguageItem item, string[] contentLines)
{
var result = new DefaultUnresolvedField(type, item.Name);
result.Region = new DomRegion((int)item.Line, 1, (int)item.Line + 1, 1);
return(result);
}
public override IUnresolvedEntity VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, object data)
{
DefaultUnresolvedField field = new DefaultUnresolvedField(currentTypeDefinition, enumMemberDeclaration.Name);
field.Region = field.BodyRegion = MakeRegion(enumMemberDeclaration);
ConvertAttributes(field.Attributes, enumMemberDeclaration.Attributes);
if (currentTypeDefinition.TypeParameters.Count == 0) {
field.ReturnType = currentTypeDefinition;
} else {
ITypeReference[] typeArgs = new ITypeReference[currentTypeDefinition.TypeParameters.Count];
for (int i = 0; i < typeArgs.Length; i++) {
typeArgs[i] = new TypeParameterReference(EntityType.TypeDefinition, i);
}
field.ReturnType = new ParameterizedTypeReference(currentTypeDefinition, typeArgs);
}
field.Accessibility = Accessibility.Public;
field.IsStatic = true;
if (!enumMemberDeclaration.Initializer.IsNull) {
field.ConstantValue = ConvertConstantValue(field.ReturnType, enumMemberDeclaration.Initializer);
} else {
DefaultUnresolvedField prevField = currentTypeDefinition.Members.LastOrDefault() as DefaultUnresolvedField;
if (prevField == null || prevField.ConstantValue == null) {
field.ConstantValue = ConvertConstantValue(field.ReturnType, new PrimitiveExpression(0));
} else {
field.ConstantValue = new IncrementConstantValue(prevField.ConstantValue);
}
}
currentTypeDefinition.Members.Add(field);
if (interningProvider != null) {
field.ApplyInterningProvider(interningProvider);
}
return field;
}
public override IUnresolvedEntity VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
{
bool isSingleField = fieldDeclaration.Variables.Count == 1;
Modifiers modifiers = fieldDeclaration.Modifiers;
DefaultUnresolvedField field = null;
foreach (VariableInitializer vi in fieldDeclaration.Variables) {
field = new DefaultUnresolvedField(currentTypeDefinition, vi.Name);
field.Region = isSingleField ? MakeRegion(fieldDeclaration) : MakeRegion(vi);
field.BodyRegion = MakeRegion(vi);
ConvertAttributes(field.Attributes, fieldDeclaration.Attributes);
ApplyModifiers(field, modifiers);
field.IsVolatile = (modifiers & Modifiers.Volatile) != 0;
field.IsReadOnly = (modifiers & Modifiers.Readonly) != 0;
field.ReturnType = fieldDeclaration.ReturnType.ToTypeReference();
if ((modifiers & Modifiers.Const) != 0) {
field.ConstantValue = ConvertConstantValue(field.ReturnType, vi.Initializer);
}
currentTypeDefinition.Members.Add(field);
if (interningProvider != null) {
field.ApplyInterningProvider(interningProvider);
}
}
return isSingleField ? field : null;
}
IField CreateFakeField(FieldReference fieldReference)
{
var declaringType = Resolve(fieldReference.DeclaringType);
var f = new DefaultUnresolvedField();
f.Name = fieldReference.Name;
lock (typeReferenceCecilLoader) {
f.ReturnType = typeReferenceCecilLoader.ReadTypeReference(fieldReference.FieldType);
}
return(new ResolvedFakeField(f, context.WithCurrentTypeDefinition(declaringType.GetDefinition()), declaringType));
}
internal static Task <IUnresolvedAssembly> LoadModuleAsync(Module module, ICorDebugModule corModule)
{
string name = corModule.GetName();
if (corModule.IsDynamic() == 1 || corModule.IsInMemory() == 1)
{
var defaultUnresolvedAssembly = new DefaultUnresolvedAssembly(name);
var defaultUnresolvedTypeDefinition = new DefaultUnresolvedTypeDefinition("UnknownDynamicType");
var defaultUnresolvedMethod = new DefaultUnresolvedMethod(defaultUnresolvedTypeDefinition, "UnknownMethod");
var defaultUnresolvedField = new DefaultUnresolvedField(defaultUnresolvedTypeDefinition, "UnknownField");
defaultUnresolvedTypeDefinition.Members.Add(defaultUnresolvedMethod);
defaultUnresolvedTypeDefinition.Members.Add(defaultUnresolvedField);
defaultUnresolvedAssembly.AddTypeDefinition(defaultUnresolvedTypeDefinition);
weakTable.Add(defaultUnresolvedAssembly, new ModuleMetadataInfo(module, null));
return(Task.FromResult <IUnresolvedAssembly>(defaultUnresolvedAssembly));
}
//return Task.FromResult(LoadModule(module, name));
return(Task.Run(() => LoadModule(module, name)));
}
public override void VisitElement(AXmlElement element)
{
string name = element.GetAttributeValue(XamlConst.XamlNamespace, "Name") ??
element.GetAttributeValue("Name");
string modifier = element.GetAttributeValue(XamlConst.XamlNamespace, "FieldModifier");
if (name != null && TypeDefinition != null)
{
var field = new DefaultUnresolvedField(TypeDefinition, name);
field.Accessibility = Accessibility.Internal;
field.ReturnType = CreateTypeReference(element.Namespace, element.LocalName);
field.Region = new DomRegion(file.FileName, textDocument.GetLocation(element.StartOffset), textDocument.GetLocation(element.EndOffset));
if (modifier != null)
{
field.Accessibility = ParseAccessibility(modifier);
}
TypeDefinition.Members.Add(field);
}
base.VisitElement(element);
}
public ResolvedFakeField(DefaultUnresolvedField unresolved, ITypeResolveContext parentContext, IType declaringType)
: base(unresolved, parentContext)
{
this.declaringType = declaringType;
}
static void GenerateCU(XmlParsedDocument doc)
{
if (doc.XDocument == null || doc.XDocument.RootElement == null)
{
doc.Add(new Error(ErrorType.Error, "No root node found.", 1, 1));
return;
}
XAttribute rootClass = doc.XDocument.RootElement.Attributes [new XName("x", "Class")];
if (rootClass == null)
{
doc.Add(new Error(ErrorType.Error, "Root node does not contain an x:Class attribute.", 1, 1));
return;
}
bool isApplication = doc.XDocument.RootElement.Name.Name == "Application";
string rootNamespace, rootType, rootAssembly;
XamlG.ParseXmlns(rootClass.Value, out rootType, out rootNamespace, out rootAssembly);
var cu = new DefaultParsedDocument(doc.FileName);
DomRegion rootRegion = doc.XDocument.RootElement.Region;
if (doc.XDocument.RootElement.IsClosed)
{
rootRegion = new DomRegion(doc.XDocument.RootElement.Region.FileName, doc.XDocument.RootElement.Region.Begin, doc.XDocument.RootElement.ClosingTag.Region.End);
}
var declType = new DefaultUnresolvedTypeDefinition(rootNamespace, rootType)
{
Kind = TypeKind.Class,
Accessibility = Accessibility.Public,
Region = rootRegion
};
cu.TopLevelTypeDefinitions.Add(declType);
var initcomp = new DefaultUnresolvedMethod(declType, "InitializeComponent")
{
ReturnType = KnownTypeReference.Void,
Accessibility = Accessibility.Public
};
declType.Members.Add(initcomp);
var _contentLoaded = new DefaultUnresolvedField(declType, "_contentLoaded")
{
ReturnType = KnownTypeReference.Boolean
};
// was missing in the original code: correct ?
// declType.Fields.Add (_contentLoaded);
if (isApplication)
{
return;
}
// cu.Add (new DomUsing (DomRegion.Empty, "System"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Controls"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Documents"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Input"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Media"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Media.Animation"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Shapes"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Controls.Primitives"));
// Dictionary<string,string> namespaceMap = new Dictionary<string, string> ();
// namespaceMap["x"] = "http://schemas.microsoft.com/winfx/2006/xaml";
XName nameAtt = new XName("x", "Name");
foreach (XElement el in doc.XDocument.RootElement.AllDescendentElements)
{
XAttribute name = el.Attributes [nameAtt];
if (name != null && name.IsComplete)
{
string type = ResolveType(el);
if (type == null || type.Length == 0)
{
cu.Add(new Error(ErrorType.Error, "Could not find namespace for '" + el.Name.FullName + "'.", el.Region.Begin));
}
else
{
declType.Members.Add(new DefaultUnresolvedField(declType, name.Value)
{
Accessibility = Accessibility.Internal,
Region = el.Region,
ReturnType = new DefaultUnresolvedTypeDefinition(type)
});
}
}
}
}
