// Keep this separate from the other TypeClassification computations as it locks in the core assembly name.
protected sealed override bool IsPrimitiveImpl()
{
CoreTypes coreTypes = Loader.GetAllFoundCoreTypes();
foreach (CoreType primitiveType in s_primitiveTypes)
{
if (this == coreTypes[primitiveType])
{
return(true);
}
}
return(false);
}
internal static BindingRestrictions GetOptionalVersionAndLanguageCheckForType(DynamicMetaObjectBinder binder, Type targetType, int expectedVersionNumber)
{
BindingRestrictions empty = BindingRestrictions.Empty;
if (CoreTypes.Contains(targetType))
{
return(empty);
}
if (expectedVersionNumber != -1)
{
empty = empty.Merge(GetVersionCheck(binder, expectedVersionNumber));
}
return(empty.Merge(GetLanguageModeCheckIfHasEverUsedConstrainedLanguage()));
}
private void dragDrop(object sender, DragEventArgs args)
{
LibraryTreeNode node = (LibraryTreeNode)args.Data.GetData(typeof(LibraryTreeNode));
FileDescriptor fDesc = FileManager.Instance.lookUp(node.FilePath);
TypeDescriptor tDesc = null;
if (fDesc is TypeDescriptor)
{
tDesc = (TypeDescriptor)fDesc;
}
else if (fDesc is ArtDescriptor)
{
tDesc = CoreTypes.getType <SimpleObject>();
}
if (tDesc != null)
{
InstanceDescriptor inst = new InstanceDescriptor(Descriptor.Level);
inst.Sprite = new Sprite(WhiskeyControl.Renderer, WhiskeyControl.Resources, inst.Sprite);
inst.Light.Visible = false;
inst.initialize(tDesc);
Point p = PointToClient(new Point(args.X, args.Y - ToolStrip.Height));
inst.Position = new Vector(p.X, p.Y);// -inst.Bounds.Size / 2;
inst.Position = WhiskeyControl.ActiveCamera.getGameCoordinate(inst.Position);
inst.X = inst.Position.X;
inst.Y = inst.Position.Y;
SelectionManager.Instance.SelectedInstance = inst;
Dirty = true;
if (fDesc is ArtDescriptor)
{
ArtDescriptor aDesc = (ArtDescriptor)fDesc;
inst.Sprite.ImagePath = aDesc.Name;
inst.Sprite.Scale = Vector.One;
}
Descriptor.Level.updateAll();
}
}
internal static bool IsAllowedInConstrainedLanguage(object targetValue, string name, bool isStatic)
{
if (!string.Equals(name, "ToString", StringComparison.OrdinalIgnoreCase))
{
Type inputType = targetValue as Type;
if (!isStatic || (inputType == null))
{
inputType = targetValue.GetType();
}
if (!CoreTypes.Contains(inputType))
{
return(false);
}
}
return(true);
}
public SystemReferences(global::Fody.TypeSystem typeSystem, ModuleDefinition moduleDefinition, IAssemblyResolver assemblyResolver)
{
var coreTypes = new CoreTypes(moduleDefinition, assemblyResolver);
IEquatable = coreTypes.GetType(typeof(IEquatable <>));
StringEquals = coreTypes.GetMethod <string, string, string, StringComparison>(nameof(string.Equals));
ObjectEquals = coreTypes.GetMethod <object, object, object>(nameof(object.Equals));
ObjectGetHashCode = coreTypes.GetMethod <object>(nameof(object.GetHashCode));
StringComparer = coreTypes.GetType <StringComparer>();
StringComparerGetHashCode = coreTypes.GetMethod <StringComparer, string>(nameof(StringComparer.GetHashCode));
StringComparerEquals = coreTypes.GetMethod <StringComparer, string, string>(nameof(StringComparer.Equals));
GeneratedCodeAttributeCtor = coreTypes.GetMethod <GeneratedCodeAttribute, string, string>(".ctor");
DebuggerNonUserCodeAttributeCtor = coreTypes.GetMethod <DebuggerNonUserCodeAttribute>(".ctor");
TypeSystem = typeSystem;
}
/// <summary>
/// Create a new MetadataLoadContext object.
/// </summary>
/// <param name="coreAssemblyName">
/// The name of the assembly that contains the core types such as System.Object. Typically, this would be "mscorlib".
/// </param>
public MetadataLoadContext(MetadataAssemblyResolver resolver, string coreAssemblyName = null)
{
if (resolver == null)
{
throw new ArgumentNullException(nameof(resolver));
}
this.resolver = resolver;
if (coreAssemblyName != null)
{
// Validate now that the value is a parsable assembly name.
new AssemblyName(coreAssemblyName);
}
// Resolve the core assembly now
_coreTypes = new CoreTypes(this, coreAssemblyName);
}
public static IEnumerable <MailDataStructureViewModel> GenerateStructure(object value)
{
if (value is IDictionary <string, object> duc)
{
foreach (var prop in duc)
{
yield return(GenerateSubStructure(prop.Key, prop.Value));
}
}
else if (value is IEnumerable list && !(value is string))
{
var first = list.ToDynamicArray().FirstOrDefault() as object;
if (!CoreTypes.ContainsKey(first?.GetType() ?? typeof(object)))
{
foreach (var item in GenerateStructure(first))
{
yield return(item);
}
}
}
private PhpCompilation(
string assemblyName,
PhpCompilationOptions options,
ImmutableArray <MetadataReference> references,
//ReferenceManager referenceManager,
//SyntaxAndDeclarationManager syntaxAndDeclarations
AsyncQueue <CompilationEvent> eventQueue = null
)
: base(assemblyName, references, SyntaxTreeCommonFeatures(ImmutableArray <SyntaxTree> .Empty), false, eventQueue)
{
_wellKnownMemberSignatureComparer = new WellKnownMembersSignatureComparer(this);
_options = options;
_referenceManager = new ReferenceManager(options.SdkDirectory);
_tables = new SourceDeclarations();
_coreTypes = new CoreTypes(this);
_coreMethods = new CoreMethods(_coreTypes);
_anonymousTypeManager = new AnonymousTypeManager(this);
}
private PhpCompilation(
string assemblyName,
PhpCompilationOptions options,
ImmutableArray <MetadataReference> references,
bool isSubmission,
ReferenceManager referenceManager = null,
bool reuseReferenceManager = false,
//SyntaxAndDeclarationManager syntaxAndDeclarations
AsyncQueue <CompilationEvent> eventQueue = null
)
: base(assemblyName, references, SyntaxTreeCommonFeatures(ImmutableArray <SyntaxTree> .Empty), isSubmission, eventQueue)
{
_wellKnownMemberSignatureComparer = new WellKnownMembersSignatureComparer(this);
_options = options;
_tables = new SourceSymbolCollection(this);
_coreTypes = new CoreTypes(this);
_coreMethods = new CoreMethods(_coreTypes);
_anonymousTypeManager = new AnonymousTypeManager(this);
_referenceManager = (reuseReferenceManager && referenceManager != null)
? referenceManager
: new ReferenceManager(MakeSourceAssemblySimpleName(), options.AssemblyIdentityComparer, referenceManager?.ObservedMetadata, options.SdkDirectory);
}
private static DirectiveAssignment ExtractDirectives(AttributeAssignment assignment)
{
var xamlDirective = CoreTypes.GetDirective(assignment.Locator.PropertyName);
return(new DirectiveAssignment(xamlDirective, assignment.Value));
}
public PhpAliasHolder(CoreTypes ct)
{
_value = null;
EnsureObject = ct.PhpAlias.Method("EnsureObject");
EnsureArray = ct.PhpAlias.Method("EnsureArray");
}
public PhpNumberHolder(CoreTypes ct)
{
ToBoolean = ct.PhpNumber.Method("ToBoolean");
ToLong = ct.PhpNumber.Method("ToLong");
ToDouble = ct.PhpNumber.Method("ToDouble");
ToString_Context = ct.PhpNumber.Method("ToString", ct.Context);
ToClass = ct.PhpNumber.Method("ToClass");
CompareTo_number = ct.PhpNumber.Method("CompareTo", ct.PhpNumber);
CompareTo_long = ct.PhpNumber.Method("CompareTo", ct.Long);
CompareTo_double = ct.PhpNumber.Method("CompareTo", ct.Double);
Create_Long = ct.PhpNumber.Method("Create", ct.Long);
Create_Double = ct.PhpNumber.Method("Create", ct.Double);
Default = ct.PhpNumber.Field("Default");
get_Long = ct.PhpNumber.Method("get_Long"); // TODO: special name, property
get_Double = ct.PhpNumber.Method("get_Double"); // TODO: special name, property
Eq_number_PhpValue = ct.PhpNumber.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpNumber, ct.PhpValue);
Ineq_number_PhpValue = ct.PhpNumber.Operator(WellKnownMemberNames.InequalityOperatorName, ct.PhpNumber, ct.PhpValue);
Eq_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpNumber, ct.PhpNumber);
Ineq_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.InequalityOperatorName, ct.PhpNumber, ct.PhpNumber);
Eq_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpNumber, ct.Long);
Ineq_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.InequalityOperatorName, ct.PhpNumber, ct.Long);
Eq_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpNumber, ct.Double);
Ineq_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.InequalityOperatorName, ct.PhpNumber, ct.Double);
Add_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.AdditionOperatorName, ct.PhpNumber, ct.PhpNumber);
Add_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.AdditionOperatorName, ct.PhpNumber, ct.Long);
Add_long_number = ct.PhpNumber.Operator(WellKnownMemberNames.AdditionOperatorName, ct.Long, ct.PhpNumber);
Add_double_number = ct.PhpNumber.Method("Add", ct.Double, ct.PhpNumber);
Add_number_double = ct.PhpNumber.Method("Add", ct.PhpNumber, ct.Double);
Add_long_long = ct.PhpNumber.Method("Add", ct.Long, ct.Long);
Add_long_double = ct.PhpNumber.Method("Add", ct.Long, ct.Double);
Add_value_long = ct.PhpNumber.Method("Add", ct.PhpValue, ct.Long);
Add_value_double = ct.PhpNumber.Method("Add", ct.PhpValue, ct.Double);
Add_value_string = ct.PhpNumber.Method("Add", ct.PhpValue, ct.String);
Add_value_number = ct.PhpNumber.Method("Add", ct.PhpValue, ct.PhpNumber);
Add_long_value = ct.PhpNumber.Method("Add", ct.Long, ct.PhpValue);
Add_double_value = ct.PhpNumber.Method("Add", ct.Double, ct.PhpValue);
Add_number_value = ct.PhpNumber.Method("Add", ct.PhpNumber, ct.PhpValue);
Add_value_value = ct.PhpNumber.Method("Add", ct.PhpValue, ct.PhpValue);
Subtract_long_long = ct.PhpNumber.Method("Sub", ct.Long, ct.Long);
Subtract_number_double = ct.PhpNumber.Method("Sub", ct.PhpNumber, ct.Double);
Subtract_long_double = ct.PhpNumber.Method("Sub", ct.Long, ct.Double);
Subtract_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.SubtractionOperatorName, ct.PhpNumber, ct.PhpNumber);
Subtract_long_number = ct.PhpNumber.Operator(WellKnownMemberNames.SubtractionOperatorName, ct.Long, ct.PhpNumber);
Subtract_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.SubtractionOperatorName, ct.PhpNumber, ct.Long);
Subtract_value_value = ct.PhpNumber.Method("Sub", ct.PhpValue, ct.PhpValue);
Subtract_value_long = ct.PhpNumber.Method("Sub", ct.PhpValue, ct.Long);
Subtract_value_double = ct.PhpNumber.Method("Sub", ct.PhpValue, ct.Double);
Subtract_value_number = ct.PhpNumber.Method("Sub", ct.PhpValue, ct.PhpNumber);
Subtract_long_value = ct.PhpNumber.Method("Sub", ct.Long, ct.PhpValue);
Negation = ct.PhpNumber.Operator(WellKnownMemberNames.UnaryNegationOperatorName, ct.PhpNumber);
Negation_long = ct.PhpNumber.Method("Minus", ct.Long);
Division_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.DivisionOperatorName, ct.PhpNumber, ct.PhpNumber);
Division_long_number = ct.PhpNumber.Operator(WellKnownMemberNames.DivisionOperatorName, ct.Long, ct.PhpNumber);
Mul_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.PhpNumber);
Mul_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.Double);
Mul_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.Long);
Mul_long_number = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.Long, ct.PhpNumber);
Mul_number_value = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.PhpValue);
Mul_value_number = ct.PhpNumber.Operator(WellKnownMemberNames.MultiplyOperatorName, ct.PhpNumber, ct.PhpValue);
Mul_long_long = ct.PhpNumber.Method("Multiply", ct.Long, ct.Long);
Mul_long_double = ct.PhpNumber.Method("Multiply", ct.Long, ct.Double);
Mul_double_value = ct.PhpNumber.Method("Multiply", ct.Double, ct.PhpValue);
Mul_long_value = ct.PhpNumber.Method("Multiply", ct.Long, ct.PhpValue);
Mul_value_value = ct.PhpNumber.Method("Multiply", ct.PhpValue, ct.PhpValue);
Mul_value_long = ct.PhpNumber.Method("Multiply", ct.PhpValue, ct.Long);
Mul_value_double = ct.PhpNumber.Method("Multiply", ct.PhpValue, ct.Double);
Pow_value_value = ct.PhpNumber.Method("Pow", ct.PhpValue, ct.PhpValue);
Pow_number_number = ct.PhpNumber.Method("Pow", ct.PhpNumber, ct.PhpNumber);
Pow_number_double = ct.PhpNumber.Method("Pow", ct.PhpNumber, ct.Double);
Pow_number_value = ct.PhpNumber.Method("Pow", ct.PhpNumber, ct.PhpValue);
Pow_double_double = ct.PhpNumber.Method("Pow", ct.Double, ct.Double);
Pow_double_value = ct.PhpNumber.Method("Pow", ct.Double, ct.PhpValue);
Pow_long_long = ct.PhpNumber.Method("Pow", ct.Long, ct.Long);
Pow_long_double = ct.PhpNumber.Method("Pow", ct.Long, ct.Double);
Pow_long_number = ct.PhpNumber.Method("Pow", ct.Long, ct.PhpNumber);
Pow_long_value = ct.PhpNumber.Method("Pow", ct.Long, ct.PhpValue);
gt_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.GreaterThanOperatorName, ct.PhpNumber, ct.PhpNumber);
gt_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.GreaterThanOperatorName, ct.PhpNumber, ct.Long);
gt_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.GreaterThanOperatorName, ct.PhpNumber, ct.Double);
lt_number_number = ct.PhpNumber.Operator(WellKnownMemberNames.LessThanOperatorName, ct.PhpNumber, ct.PhpNumber);
lt_number_long = ct.PhpNumber.Operator(WellKnownMemberNames.LessThanOperatorName, ct.PhpNumber, ct.Long);
lt_number_double = ct.PhpNumber.Operator(WellKnownMemberNames.LessThanOperatorName, ct.PhpNumber, ct.Double);
}
public virtual string Format(decimal v)
{
return CoreTypes.CastToString(v);
}
public virtual string Format(ulong v)
{
return CoreTypes.CastToString(v);
}
public ConstructorsHolder(CoreTypes ct)
{
PhpAlias_PhpValue_int = ct.PhpAlias.Ctor(ct.PhpValue, ct.Int32);
PhpString = ct.PhpString.Ctor();
PhpString_string = ct.PhpString.Ctor(ct.String);
PhpString_string_string = ct.PhpString.Ctor(ct.String, ct.String);
PhpArray = ct.PhpArray.Ctor();
PhpArray_int = ct.PhpArray.Ctor(ct.Int32);
IntStringKey_int = ct.IntStringKey.Ctor(ct.Int32);
IntStringKey_string = ct.IntStringKey.Ctor(ct.String);
ScriptAttribute_string = ct.ScriptAttribute.Ctor(ct.String);
ScriptDiedException = ct.ScriptDiedException.Ctor();
ScriptDiedException_Long = ct.ScriptDiedException.Ctor(ct.Long);
ScriptDiedException_PhpValue = ct.ScriptDiedException.Ctor(ct.PhpValue);
}
public PhpStringHolder(CoreTypes ct)
{
ToBoolean = ct.PhpString.Method("ToBoolean");
ToLong = ct.PhpString.Method("ToLong");
ToDouble = ct.PhpString.Method("ToDouble");
ToString_Context = ct.PhpString.Method("ToString", ct.Context);
Append_String = ct.PhpString.Method("Append", ct.String);
Append_PhpString = ct.PhpString.Method("Append", ct.PhpString);
}
/// <summary> /// Returns a lazily created and cached array containing the resolved CoreTypes, indexed by the CoreType enum cast to an int. /// If the core assembly was not specified, not locatable or if one or more core types aren't present in the core assembly, /// the corresponding elements will be null. /// </summary> internal CoreTypes GetAllFoundCoreTypes() => _lazyCoreTypes ?? (_lazyCoreTypes = new CoreTypes(this));
public IPhpArrayHolder(CoreTypes ct)
{
var arr = ct.IPhpArray;
RemoveKey_IntStringKey = arr.Method("RemoveKey", ct.IntStringKey);
GetItemValue_IntStringKey = arr.Method("GetItemValue", ct.IntStringKey);
SetItemValue_IntStringKey_PhpValue = arr.Method("SetItemValue", ct.IntStringKey, ct.PhpValue);
SetItemAlias_IntStringKey_PhpAlias = arr.Method("SetItemAlias", ct.IntStringKey, ct.PhpAlias);
AddValue_PhpValue = arr.Method("AddValue", ct.PhpValue);
EnsureItemObject_IntStringKey = arr.Method("EnsureItemObject", ct.IntStringKey);
EnsureItemArray_IntStringKey = arr.Method("EnsureItemArray", ct.IntStringKey);
EnsureItemAlias_IntStringKey = arr.Method("EnsureItemAlias", ct.IntStringKey);
get_Count = arr.Method("get_Count");
}
private bool BlockMethodInLanguageMode(object inputObject)
{
if (base.Context.LanguageMode.Equals(PSLanguageMode.RestrictedLanguage))
{
PSInvalidOperationException exception = new PSInvalidOperationException(InternalCommandStrings.NoMethodInvocationInRestrictedLanguageMode);
base.WriteError(new ErrorRecord(exception, "NoMethodInvocationInRestrictedLanguageMode", ErrorCategory.InvalidOperation, null));
return(true);
}
if (base.Context.LanguageMode.Equals(PSLanguageMode.ConstrainedLanguage) && !CoreTypes.Contains(PSObject.Base(inputObject).GetType()))
{
PSInvalidOperationException exception2 = new PSInvalidOperationException(ParserStrings.InvokeMethodConstrainedLanguage);
base.WriteError(new ErrorRecord(exception2, "MethodInvocationNotSupportedInConstrainedLanguage", ErrorCategory.InvalidOperation, null));
return(true);
}
return(false);
}
public ReflectionHolder(CoreTypes ct)
{
CreateUserRoutine_string_RuntimeMethodHandle = ct.RoutineInfo.Method("CreateUserRoutine", ct.String, ct.RuntimeMethodHandle);
}
public DynamicHolder(CoreTypes ct)
{
CallBinderFactory_Function = ct.CallBinderFactory.Method("Function", ct.String, ct.String, ct.RuntimeTypeHandle, ct.Int32);
CallBinderFactory_InstanceFunction = ct.CallBinderFactory.Method("InstanceFunction", ct.String, ct.RuntimeTypeHandle, ct.RuntimeTypeHandle, ct.Int32);
CallBinderFactory_StaticFunction = ct.CallBinderFactory.Method("StaticFunction", ct.RuntimeTypeHandle, ct.String, ct.RuntimeTypeHandle, ct.RuntimeTypeHandle, ct.Int32);
GetFieldBinder_ctor = ct.GetFieldBinder.Ctor(ct.String, ct.RuntimeTypeHandle, ct.RuntimeTypeHandle, ct.AccessFlags);
SetFieldBinder_ctor = ct.SetFieldBinder.Ctor(ct.String, ct.RuntimeTypeHandle, ct.AccessFlags);
GetPhpTypeInfo_T = ct.PhpTypeInfoExtension.Method("GetPhpTypeInfo");
}
public ContextHolder(CoreTypes ct)
{
AddScriptReference_TScript = ct.Context.Method("AddScriptReference");
Dispose = ct.Context.Method("Dispose");
DeclareFunction_RoutineInfo = ct.Context.Method("DeclareFunction", ct.RoutineInfo);
DeclareType_T = ct.Context.Method("DeclareType");
DisableErrorReporting = ct.Context.Method("DisableErrorReporting");
EnableErrorReporting = ct.Context.Method("EnableErrorReporting");
CheckIncludeOnce_TScript = ct.Context.Method("CheckIncludeOnce");
OnInclude_TScript = ct.Context.Method("OnInclude");
Include_string_string_PhpArray_object_bool_bool = ct.Context.Method("Include", ct.String, ct.String, ct.PhpArray, ct.Object, ct.Boolean, ct.Boolean);
ScriptPath_TScript = ct.Context.Method("ScriptPath");
GetConstant_string_int32 = ct.Context.Method("GetConstant", ct.String, ct.Int32);
GetStatic_T = ct.Context.Method("GetStatic");
GetDeclaredType_string = ct.Context.Method("GetDeclaredType", ct.String);
// properties
Globals = ct.Context.Property("Globals");
Server = ct.Context.Property("Server");
Request = ct.Context.Property("Request");
Get = ct.Context.Property("Get");
Post = ct.Context.Property("Post");
Cookie = ct.Context.Property("Cookie");
Env = ct.Context.Property("Env");
Files = ct.Context.Property("Files");
Session = ct.Context.Property("Session");
}
protected override void BeginProcessing()
{
Type result = null;
PSArgumentException exception = null;
if (string.Compare(base.ParameterSetName, "Net", StringComparison.Ordinal) == 0)
{
object o = null;
if (!LanguagePrimitives.TryConvertTo <Type>(this.typeName, out result))
{
exception = PSTraceSource.NewArgumentException("TypeName", "NewObjectStrings", "TypeNotFound", new object[] { this.typeName });
base.ThrowTerminatingError(new ErrorRecord(exception, "TypeNotFound", ErrorCategory.InvalidType, null));
}
if ((base.Context.LanguageMode == PSLanguageMode.ConstrainedLanguage) && !CoreTypes.Contains(result))
{
base.ThrowTerminatingError(new ErrorRecord(new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null));
}
if (WinRTHelper.IsWinRTType(result) && (typeof(Attribute).IsAssignableFrom(result) || typeof(Delegate).IsAssignableFrom(result)))
{
base.ThrowTerminatingError(new ErrorRecord(new InvalidOperationException(NewObjectStrings.CannotInstantiateWinRTType), "CannotInstantiateWinRTType", ErrorCategory.InvalidOperation, null));
}
if ((this.arguments == null) || (this.arguments.Length == 0))
{
ConstructorInfo constructor = result.GetConstructor(Type.EmptyTypes);
if ((constructor != null) && constructor.IsPublic)
{
o = this.CallConstructor(result, new ConstructorInfo[] { constructor }, new object[0]);
if ((o != null) && (this.property != null))
{
o = LanguagePrimitives.SetObjectProperties(o, this.Property, result, new LanguagePrimitives.MemberNotFoundError(this.CreateMemberNotFoundError), new LanguagePrimitives.MemberSetValueError(this.CreateMemberSetValueError), true);
}
base.WriteObject(o);
return;
}
if (result.IsValueType)
{
try
{
o = Activator.CreateInstance(result, false);
if ((o != null) && (this.property != null))
{
o = LanguagePrimitives.SetObjectProperties(o, this.Property, result, new LanguagePrimitives.MemberNotFoundError(this.CreateMemberNotFoundError), new LanguagePrimitives.MemberSetValueError(this.CreateMemberSetValueError), true);
}
}
catch (TargetInvocationException exception2)
{
base.ThrowTerminatingError(new ErrorRecord((exception2.InnerException == null) ? exception2 : exception2.InnerException, "ConstructorCalledThrowException", ErrorCategory.InvalidOperation, null));
}
base.WriteObject(o);
return;
}
}
else
{
ConstructorInfo[] constructors = result.GetConstructors();
if (constructors.Length != 0)
{
o = this.CallConstructor(result, constructors, this.arguments);
if ((o != null) && (this.property != null))
{
o = LanguagePrimitives.SetObjectProperties(o, this.Property, result, new LanguagePrimitives.MemberNotFoundError(this.CreateMemberNotFoundError), new LanguagePrimitives.MemberSetValueError(this.CreateMemberSetValueError), true);
}
base.WriteObject(o);
return;
}
}
exception = PSTraceSource.NewArgumentException("TypeName", "NewObjectStrings", "CannotFindAppropriateCtor", new object[] { this.typeName });
base.ThrowTerminatingError(new ErrorRecord(exception, "CannotFindAppropriateCtor", ErrorCategory.ObjectNotFound, null));
}
else
{
NewObjectNativeMethods.CLSIDFromProgID(this.comObject, out this.comObjectClsId);
if (base.Context.LanguageMode == PSLanguageMode.ConstrainedLanguage)
{
bool flag2 = false;
if ((SystemPolicy.GetSystemLockdownPolicy() == SystemEnforcementMode.Enforce) && SystemPolicy.IsClassInApprovedList(this.comObjectClsId))
{
flag2 = true;
}
if (!flag2)
{
base.ThrowTerminatingError(new ErrorRecord(new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateComTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null));
return;
}
}
PSSQMAPI.IncrementDataPoint((int)0x2099);
object targetObject = this.CreateComObject();
string fullName = targetObject.GetType().FullName;
if (!fullName.Equals("System.__ComObject"))
{
exception = PSTraceSource.NewArgumentException("TypeName", "NewObjectStrings", "ComInteropLoaded", new object[] { fullName });
base.WriteVerbose(exception.Message);
if (this.Strict != 0)
{
base.WriteError(new ErrorRecord(exception, "ComInteropLoaded", ErrorCategory.InvalidArgument, targetObject));
}
}
if ((targetObject != null) && (this.property != null))
{
targetObject = LanguagePrimitives.SetObjectProperties(targetObject, this.Property, result, new LanguagePrimitives.MemberNotFoundError(this.CreateMemberNotFoundError), new LanguagePrimitives.MemberSetValueError(this.CreateMemberSetValueError), true);
}
base.WriteObject(targetObject);
}
}
public PhpValueHolder(CoreTypes ct)
{
ToBoolean = ct.PhpValue.Method("ToBoolean");
ToLong = ct.PhpValue.Method("ToLong");
ToDouble = ct.PhpValue.Method("ToDouble");
ToString_Context = ct.PhpValue.Method("ToString", ct.Context);
ToClass = ct.PhpValue.Method("ToClass");
EnsureObject = ct.PhpValue.Method("EnsureObject");
EnsureArray = ct.PhpValue.Method("EnsureArray");
EnsureAlias = ct.PhpValue.Method("EnsureAlias");
Eq_PhpValue_PhpValue = ct.PhpValue.Operator(WellKnownMemberNames.EqualityOperatorName, ct.PhpValue, ct.PhpValue);
DeepCopy = ct.PhpValue.Method("DeepCopy");
ToArray = ct.PhpValue.Method("ToArray");
AsObject = ct.PhpValue.Method("AsObject");
get_Long = ct.PhpValue.Method("get_Long"); // TODO: special name, property
get_Double = ct.PhpValue.Method("get_Double"); // TODO: special name, property
get_Boolean = ct.PhpValue.Method("get_Boolean"); // TODO: special name, property
get_String = ct.PhpValue.Method("get_String"); // TODO: special name, property
get_Object = ct.PhpValue.Method("get_Object"); // TODO: special name, property
get_Array = ct.PhpValue.Method("get_Array"); // TODO: special name, property
Create_Boolean = ct.PhpValue.Method("Create", ct.Boolean);
Create_Long = ct.PhpValue.Method("Create", ct.Long);
Create_Double = ct.PhpValue.Method("Create", ct.Double);
Create_String = ct.PhpValue.Method("Create", ct.String);
Create_PhpString = ct.PhpValue.Method("Create", ct.PhpString);
Create_PhpNumber = ct.PhpValue.Method("Create", ct.PhpNumber);
Create_PhpArray = ct.PhpValue.Method("Create", ct.PhpArray);
Create_PhpAlias = ct.PhpValue.Method("Create", ct.PhpAlias);
Create_IntStringKey = ct.PhpValue.Method("Create", ct.IntStringKey);
FromClr_Object = ct.PhpValue.Method("FromClr", ct.Object);
FromClass_Object = ct.PhpValue.Method("FromClass", ct.Object);
Void = ct.PhpValue.Field("Void");
Null = ct.PhpValue.Field("Null");
}
public static bool TryFindRawDefaultValueFromCustomAttributes(this CustomAttributeHandleCollection handles, EcmaModule module, out object rawDefaultValue)
{
rawDefaultValue = default;
MetadataReader reader = module.Reader;
foreach (CustomAttributeHandle handle in handles)
{
CustomAttribute ca = handle.GetCustomAttribute(reader);
EntityHandle declaringTypeHandle = ca.TryGetDeclaringTypeHandle(reader);
if (declaringTypeHandle.IsNil)
{
continue;
}
if (declaringTypeHandle.TypeMatchesNameAndNamespace(Utf8Constants.SystemRuntimeCompilerServices, Utf8Constants.DateTimeConstantAttribute, reader))
{
CustomAttributeData cad = handle.ToCustomAttributeData(module);
IList <CustomAttributeTypedArgument> cats = cad.ConstructorArguments;
if (cats.Count != 1)
{
return(false);
}
CoreTypes ct = module.Loader.GetAllFoundCoreTypes();
if (cats[0].ArgumentType != ct[CoreType.Int64])
{
return(false);
}
long ticks = (long)(cats[0].Value);
rawDefaultValue = new DateTimeConstantAttribute(ticks).Value;
return(true);
}
if (declaringTypeHandle.TypeMatchesNameAndNamespace(Utf8Constants.SystemRuntimeCompilerServices, Utf8Constants.DecimalConstantAttribute, reader))
{
CustomAttributeData cad = handle.ToCustomAttributeData(module);
IList <CustomAttributeTypedArgument> cats = cad.ConstructorArguments;
if (cats.Count != 5)
{
return(false);
}
CoreTypes ct = module.Loader.GetAllFoundCoreTypes();
if (cats[0].ArgumentType != ct[CoreType.Byte] ||
cats[1].ArgumentType != ct[CoreType.Byte])
{
return(false);
}
byte scale = (byte)cats[0].Value;
byte sign = (byte)cats[1].Value;
if (cats[2].ArgumentType == ct[CoreType.Int32] && cats[3].ArgumentType == ct[CoreType.Int32] && cats[4].ArgumentType == ct[CoreType.Int32])
{
int hi = (int)cats[2].Value;
int mid = (int)cats[3].Value;
int lo = (int)cats[4].Value;
rawDefaultValue = new DecimalConstantAttribute(scale, sign, hi, mid, lo).Value;
return(true);
}
if (cats[2].ArgumentType == ct[CoreType.UInt32] && cats[3].ArgumentType == ct[CoreType.UInt32] && cats[4].ArgumentType == ct[CoreType.UInt32])
{
uint hi = (uint)cats[2].Value;
uint mid = (uint)cats[3].Value;
uint lo = (uint)cats[4].Value;
rawDefaultValue = new DecimalConstantAttribute(scale, sign, hi, mid, lo).Value;
return(true);
}
return(false);
}
// Should we also look for CustomConstantAttribute too? Who uses that (other than DateTimeConstantAttribute which
// we handled above?) CustomConstantAttribute is an abstract class which means we have to figure out how a subclass
// we've never heard of would set the "Value" property which is kinda hard to do when you can't Invoke().
// Even the CLR doesn't return consistent values for this between the raw and non-raw versions.
// Even doing the subclass check would open the door to resolving types and dependency assemblies and their
// resulting FileNotFoundExceptions. Which is exactly what we're trying to avoid with this name-based lookup approach.
}
return(false);
}
public OperatorsHolder(CoreTypes ct)
{
SetValue_PhpValueRef_PhpValue = ct.Operators.Method("SetValue", ct.PhpValue, ct.PhpValue);
EnsureObject_ObjectRef = ct.Operators.Method("EnsureObject", ct.Object);
EnsureArray_PhpArrayRef = ct.Operators.Method("EnsureArray", ct.PhpArray);
EnsureArray_IPhpArrayRef = ct.Operators.Method("EnsureArray", ct.IPhpArray);
IsSet_PhpValue = ct.Operators.Method("IsSet", ct.PhpValue);
IsEmpty_PhpValue = ct.Operators.Method("IsEmpty", ct.PhpValue);
ToString_Bool = ct.Convert.Method("ToString", ct.Boolean);
ToString_Int32 = ct.Convert.Method("ToString", ct.Int32);
ToString_Long = ct.Convert.Method("ToString", ct.Long);
ToString_Double_Context = ct.Convert.Method("ToString", ct.Double, ct.Context);
Long_ToString = ct.Long.Method("ToString");
ToBoolean_String = ct.Convert.Method("ToBoolean", ct.String);
ToBoolean_PhpValue = new CoreExplicitCast(ct.PhpValue, ct.Boolean);
ToBoolean_Object = ct.Convert.Method("ToBoolean", ct.Object);
ToLong_PhpValue = new CoreExplicitCast(ct.PhpValue, ct.Long);
ToDouble_PhpValue = new CoreExplicitCast(ct.PhpValue, ct.Double);
ToNumber_PhpValue = ct.Convert.Method("ToNumber", ct.PhpValue);
ToLong_String = ct.Convert.Method("StringToLongInteger", ct.String);
ToDouble_String = ct.Convert.Method("StringToDouble", ct.String);
AsObject_PhpValue = ct.Convert.Method("AsObject", ct.PhpValue);
ToArray_PhpValue = ct.Convert.Method("ToArray", ct.PhpValue);
ToClass_PhpValue = ct.Convert.Method("ToClass", ct.PhpValue);
ToClass_IPhpArray = ct.Convert.Method("ToClass", ct.IPhpArray);
AsCallable_PhpValue = ct.Convert.Method("AsCallable", ct.PhpValue);
AsCallable_String = ct.Convert.Method("AsCallable", ct.String);
IsInstanceOf_Object_PhpTypeInfo = ct.Convert.Method("IsInstanceOf", ct.Object, ct.PhpTypeInfo);
ToIntStringKey_PhpValue = ct.Convert.Method("ToIntStringKey", ct.PhpValue);
Echo_String = ct.Context.Method("Echo", ct.String);
Echo_PhpString = ct.Context.Method("Echo", ct.PhpString);
Echo_PhpNumber = ct.Context.Method("Echo", ct.PhpNumber);
Echo_PhpValue = ct.Context.Method("Echo", ct.PhpValue);
Echo_Object = ct.Context.Method("Echo", ct.Object);
Echo_Double = ct.Context.Method("Echo", ct.Double);
Echo_Long = ct.Context.Method("Echo", ct.Long);
Echo_Int32 = ct.Context.Method("Echo", ct.Int32);
GetForeachEnumerator_PhpValue_Bool_RuntimeTypeHandle = ct.Operators.Method("GetForeachEnumerator", ct.PhpValue, ct.Boolean, ct.RuntimeTypeHandle);
Ceq_long_double = ct.Comparison.Method("Ceq", ct.Long, ct.Double);
Ceq_long_bool = ct.Comparison.Method("Ceq", ct.Long, ct.Boolean);
Ceq_long_string = ct.Comparison.Method("Ceq", ct.Long, ct.String);
Ceq_double_string = ct.Comparison.Method("Ceq", ct.Double, ct.String);
Ceq_string_long = ct.Comparison.Method("Ceq", ct.String, ct.Long);
Ceq_string_double = ct.Comparison.Method("Ceq", ct.String, ct.Double);
Ceq_string_bool = ct.Comparison.Method("Ceq", ct.String, ct.Boolean);
Clt_long_double = ct.Comparison.Method("Clt", ct.Long, ct.Double);
Cgt_long_double = ct.Comparison.Method("Cgt", ct.Long, ct.Double);
Compare_bool_bool = ct.Comparison.Method("Compare", ct.Boolean, ct.Boolean);
Compare_number_value = ct.Comparison.Method("Compare", ct.PhpNumber, ct.PhpValue);
Compare_long_value = ct.Comparison.Method("Compare", ct.Long, ct.PhpValue);
Compare_double_value = ct.Comparison.Method("Compare", ct.Double, ct.PhpValue);
Compare_bool_value = ct.Comparison.Method("Compare", ct.Boolean, ct.PhpValue);
Compare_value_value = ct.Comparison.Method("Compare", ct.PhpValue, ct.PhpValue);
Compare_string_string = ct.Comparison.Method("Compare", ct.String, ct.String);
Compare_string_long = ct.Comparison.Method("Compare", ct.String, ct.Long);
Compare_string_double = ct.Comparison.Method("Compare", ct.String, ct.Double);
Compare_string_value = ct.Comparison.Method("Compare", ct.String, ct.PhpValue);
StrictCeq_bool_PhpValue = ct.StrictComparison.Method("Ceq", ct.Boolean, ct.PhpValue);
StrictCeq_long_PhpValue = ct.StrictComparison.Method("Ceq", ct.Long, ct.PhpValue);
StrictCeq_double_PhpValue = ct.StrictComparison.Method("Ceq", ct.Double, ct.PhpValue);
StrictCeq_PhpValue_PhpValue = ct.StrictComparison.Method("Ceq", ct.PhpValue, ct.PhpValue);
StrictCeq_PhpValue_bool = ct.StrictComparison.Method("Ceq", ct.PhpValue, ct.Boolean);
Div_PhpValue_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.DivisionOperatorName, ct.PhpValue, ct.PhpValue);
Div_long_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.DivisionOperatorName, ct.Long, ct.PhpValue);
Div_double_PhpValue = ct.PhpNumber.Method(WellKnownMemberNames.DivisionOperatorName, ct.Double, ct.PhpValue);
BitwiseOr_PhpValue_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.BitwiseOrOperatorName, ct.PhpValue, ct.PhpValue);
BitwiseAnd_PhpValue_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.BitwiseAndOperatorName, ct.PhpValue, ct.PhpValue);
BitwiseNot_PhpValue = ct.PhpValue.Method(WellKnownMemberNames.OnesComplementOperatorName, ct.PhpValue);
}
public PhpArrayHolder(CoreTypes ct)
{
var t = ct.PhpArray;
//
ToString_Context = t.Method("ToString", ct.Context);
ToClass = t.Method("ToClass");
ToBoolean = t.Method("ToBoolean");
RemoveKey_IntStringKey = t.Method("RemoveKey", ct.IntStringKey);
GetItemValue_IntStringKey = t.Method("GetItemValue", ct.IntStringKey);
DeepCopy = t.Method("DeepCopy");
GetForeachEnumerator_Boolean = t.Method("GetForeachEnumerator", ct.Boolean);
SetItemValue_IntStringKey_PhpValue = t.Method("SetItemValue", ct.IntStringKey, ct.PhpValue);
SetItemAlias_IntStringKey_PhpAlias = t.Method("SetItemAlias", ct.IntStringKey, ct.PhpAlias);
AddValue_PhpValue = t.Method("AddValue", ct.PhpValue);
EnsureItemObject_IntStringKey = t.Method("EnsureItemObject", ct.IntStringKey);
EnsureItemArray_IntStringKey = t.Method("EnsureItemArray", ct.IntStringKey);
EnsureItemAlias_IntStringKey = t.Method("EnsureItemAlias", ct.IntStringKey);
New_PhpValue = t.Method("New", ct.PhpValue);
}
/// <summary> Create the object </summary>
protected override void BeginProcessing()
{
Type type = null;
PSArgumentException mshArgE = null;
if (string.Compare(ParameterSetName, netSetName, StringComparison.Ordinal) == 0)
{
object _newObject = null;
try
{
type = LanguagePrimitives.ConvertTo(TypeName, typeof(Type), CultureInfo.InvariantCulture) as Type;
}
catch (Exception e)
{
// these complications in Exception handling are aim to make error messages better.
if (e is InvalidCastException || e is ArgumentException)
{
if (e.InnerException != null && e.InnerException is TypeResolver.AmbiguousTypeException)
{
ThrowTerminatingError(
new ErrorRecord(
e,
"AmbiguousTypeReference",
ErrorCategory.InvalidType,
targetObject: null));
}
mshArgE = PSTraceSource.NewArgumentException(
"TypeName",
NewObjectStrings.TypeNotFound,
TypeName);
ThrowTerminatingError(
new ErrorRecord(
mshArgE,
"TypeNotFound",
ErrorCategory.InvalidType,
targetObject: null));
}
throw e;
}
Diagnostics.Assert(type != null, "LanguagePrimitives.TryConvertTo failed but returned true");
if (type.IsByRefLike)
{
ThrowTerminatingError(
new ErrorRecord(
PSTraceSource.NewInvalidOperationException(
NewObjectStrings.CannotInstantiateBoxedByRefLikeType,
type),
nameof(NewObjectStrings.CannotInstantiateBoxedByRefLikeType),
ErrorCategory.InvalidOperation,
targetObject: null));
}
if (Context.LanguageMode == PSLanguageMode.ConstrainedLanguage)
{
if (!CoreTypes.Contains(type))
{
ThrowTerminatingError(
new ErrorRecord(
new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null));
}
}
// WinRT does not support creating instances of attribute & delegate WinRT types.
if (WinRTHelper.IsWinRTType(type) && ((typeof(System.Attribute)).IsAssignableFrom(type) || (typeof(System.Delegate)).IsAssignableFrom(type)))
{
ThrowTerminatingError(new ErrorRecord(new InvalidOperationException(NewObjectStrings.CannotInstantiateWinRTType),
"CannotInstantiateWinRTType", ErrorCategory.InvalidOperation, null));
}
if (ArgumentList == null || ArgumentList.Length == 0)
{
ConstructorInfo ci = type.GetConstructor(Type.EmptyTypes);
if (ci != null && ci.IsPublic)
{
_newObject = CallConstructor(type, new ConstructorInfo[] { ci }, new object[] { });
if (_newObject != null && Property != null)
{
// The method invocation is disabled for "Hashtable to Object conversion" (Win8:649519), but we need to keep it enabled for New-Object for compatibility to PSv2
_newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
WriteObject(_newObject);
return;
}
else if (type.GetTypeInfo().IsValueType)
{
// This is for default parameterless struct ctor which is not returned by
// Type.GetConstructor(System.Type.EmptyTypes).
try
{
_newObject = Activator.CreateInstance(type);
if (_newObject != null && Property != null)
{
// Win8:649519
_newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
}
catch (TargetInvocationException e)
{
ThrowTerminatingError(
new ErrorRecord(
e.InnerException ?? e,
"ConstructorCalledThrowException",
ErrorCategory.InvalidOperation, null));
}
WriteObject(_newObject);
return;
}
}
else
{
ConstructorInfo[] ctorInfos = type.GetConstructors();
if (ctorInfos.Length != 0)
{
_newObject = CallConstructor(type, ctorInfos, ArgumentList);
if (_newObject != null && Property != null)
{
// Win8:649519
_newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
WriteObject(_newObject);
return;
}
}
mshArgE = PSTraceSource.NewArgumentException(
"TypeName", NewObjectStrings.CannotFindAppropriateCtor, TypeName);
ThrowTerminatingError(
new ErrorRecord(
mshArgE,
"CannotFindAppropriateCtor",
ErrorCategory.ObjectNotFound, null));
}
#if !UNIX
else // Parameterset -Com
{
int result = NewObjectNativeMethods.CLSIDFromProgID(ComObject, out _comObjectClsId);
// If we're in ConstrainedLanguage, do additional restrictions
if (Context.LanguageMode == PSLanguageMode.ConstrainedLanguage)
{
bool isAllowed = false;
// If it's a system-wide lockdown, we may allow additional COM types
if (SystemPolicy.GetSystemLockdownPolicy() == SystemEnforcementMode.Enforce)
{
if ((result >= 0) &&
SystemPolicy.IsClassInApprovedList(_comObjectClsId))
{
isAllowed = true;
}
}
if (!isAllowed)
{
ThrowTerminatingError(
new ErrorRecord(
new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateComTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null));
return;
}
}
object comObject = CreateComObject();
string comObjectTypeName = comObject.GetType().FullName;
if (!comObjectTypeName.Equals("System.__ComObject"))
{
mshArgE = PSTraceSource.NewArgumentException(
"TypeName", NewObjectStrings.ComInteropLoaded, comObjectTypeName);
WriteVerbose(mshArgE.Message);
if (Strict)
{
WriteError(new ErrorRecord(
mshArgE,
"ComInteropLoaded",
ErrorCategory.InvalidArgument, comObject));
}
}
if (comObject != null && Property != null)
{
// Win8:649519
comObject = LanguagePrimitives.SetObjectProperties(comObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
WriteObject(comObject);
}
#endif
}
private PhpCompilation(
string assemblyName,
PhpCompilationOptions options,
ImmutableArray<MetadataReference> references,
//ReferenceManager referenceManager,
//SyntaxAndDeclarationManager syntaxAndDeclarations
AsyncQueue<CompilationEvent> eventQueue = null
)
: base(assemblyName, references, SyntaxTreeCommonFeatures(ImmutableArray<SyntaxTree>.Empty), false, eventQueue)
{
_wellKnownMemberSignatureComparer = new WellKnownMembersSignatureComparer(this);
_options = options;
_referenceManager = new ReferenceManager(options.SdkDirectory);
_tables = new SourceDeclarations();
_coreTypes = new CoreTypes(this);
_coreMethods = new CoreMethods(_coreTypes);
_anonymousTypeManager = new AnonymousTypeManager(this);
}
/// <summary> Create the object </summary>
protected override void BeginProcessing()
{
Type type = null;
PSArgumentException mshArgE = null;
if (string.Equals(ParameterSetName, netSetName, StringComparison.Ordinal))
{
object _newObject = null;
try
{
type = LanguagePrimitives.ConvertTo(TypeName, typeof(Type), CultureInfo.InvariantCulture) as Type;
}
catch (Exception e)
{
// these complications in Exception handling are aim to make error messages better.
if (e is InvalidCastException || e is ArgumentException)
{
if (e.InnerException != null && e.InnerException is TypeResolver.AmbiguousTypeException)
{
ThrowTerminatingError(
new ErrorRecord(
e,
"AmbiguousTypeReference",
ErrorCategory.InvalidType,
targetObject: null));
}
mshArgE = PSTraceSource.NewArgumentException(
"TypeName",
NewObjectStrings.TypeNotFound,
TypeName);
ThrowTerminatingError(
new ErrorRecord(
mshArgE,
"TypeNotFound",
ErrorCategory.InvalidType,
targetObject: null));
}
throw;
}
Diagnostics.Assert(type != null, "LanguagePrimitives.TryConvertTo failed but returned true");
if (type.IsByRefLike)
{
ThrowTerminatingError(
new ErrorRecord(
PSTraceSource.NewInvalidOperationException(
NewObjectStrings.CannotInstantiateBoxedByRefLikeType,
type),
nameof(NewObjectStrings.CannotInstantiateBoxedByRefLikeType),
ErrorCategory.InvalidOperation,
targetObject: null));
}
if (Context.LanguageMode == PSLanguageMode.ConstrainedLanguage)
{
if (!CoreTypes.Contains(type))
{
ThrowTerminatingError(
new ErrorRecord(
new PSNotSupportedException(NewObjectStrings.CannotCreateTypeConstrainedLanguage), "CannotCreateTypeConstrainedLanguage", ErrorCategory.PermissionDenied, null));
}
}
// WinRT does not support creating instances of attribute & delegate WinRT types.
if (WinRTHelper.IsWinRTType(type) && ((typeof(System.Attribute)).IsAssignableFrom(type) || (typeof(System.Delegate)).IsAssignableFrom(type)))
{
ThrowTerminatingError(new ErrorRecord(new InvalidOperationException(NewObjectStrings.CannotInstantiateWinRTType),
"CannotInstantiateWinRTType", ErrorCategory.InvalidOperation, null));
}
if (ArgumentList is null || ArgumentList.Length == 0)
{
ConstructorInfo ci = type.GetConstructor(Type.EmptyTypes);
if (ci != null && ci.IsPublic)
{
_newObject = CallConstructor(type, new ConstructorInfo[] { ci }, new object[] { });
if (_newObject != null && Property != null)
{
// The method invocation is disabled for "Hashtable to Object conversion" (Win8:649519), but we need to keep it enabled for New-Object for compatibility to PSv2
_newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
WriteObject(_newObject);
return;
}
else if (type.GetTypeInfo().IsValueType)
{
// This is for default parameterless struct ctor which is not returned by
// Type.GetConstructor(System.Type.EmptyTypes).
try
{
_newObject = Activator.CreateInstance(type);
if (_newObject != null && Property != null)
{
// Win8:649519
_newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
}
catch (TargetInvocationException e)
{
ThrowTerminatingError(
new ErrorRecord(
e.InnerException ?? e,
"ConstructorCalledThrowException",
ErrorCategory.InvalidOperation, null));
}
WriteObject(_newObject);
return;
}
}
else
{
ConstructorInfo[] ctorInfos = type.GetConstructors();
if (ctorInfos.Length != 0)
{
_newObject = CallConstructor(type, ctorInfos, ArgumentList);
if (_newObject != null && Property != null)
{
// Win8:649519
_newObject = LanguagePrimitives.SetObjectProperties(_newObject, Property, type, CreateMemberNotFoundError, CreateMemberSetValueError, enableMethodCall: true);
}
WriteObject(_newObject);
return;
}
}
mshArgE = PSTraceSource.NewArgumentException(
"TypeName", NewObjectStrings.CannotFindAppropriateCtor, TypeName);
ThrowTerminatingError(
new ErrorRecord(
mshArgE,
"CannotFindAppropriateCtor",
ErrorCategory.ObjectNotFound, null));
}
public virtual string Format(DateTime v)
{
return CoreTypes.CastToString(v);
}
/// <summary>
/// Returns a lazily created and cached Type instance corresponding to the indicated core type. This method returns null
/// if the core assembly name wasn't supplied, the core assembly could not be loaded for some reason or if the specified
/// type does not exist in the core assembly.
/// </summary>
internal RoType?TryGetCoreType(CoreType coreType)
{
CoreTypes coreTypes = GetAllFoundCoreTypes();
return(coreTypes[coreType]);
}
public virtual string Format(Duration v)
{
return CoreTypes.CastToString(v);
}
public override string Format(double v)
{
return CoreTypes.CastToString((long) v);
}
public CoreMethods(CoreTypes types)
{
Contract.ThrowIfNull(types);
PhpValue = new PhpValueHolder(types);
PhpAlias = new PhpAliasHolder(types);
PhpArray = new PhpArrayHolder(types);
IPhpArray = new IPhpArrayHolder(types);
PhpNumber = new PhpNumberHolder(types);
PhpString = new PhpStringHolder(types);
Operators = new OperatorsHolder(types);
Ctors = new ConstructorsHolder(types);
Context = new ContextHolder(types);
Dynamic = new DynamicHolder(types);
Reflection = new ReflectionHolder(types);
}
